// frontir/edge — request router
import { sites, cache, origin } from "@frontir/core"
export async function handle(req: Request): Promise<Response> {
const host = req.headers.get("host") ?? ""
const site = await sites.lookup(host)
if (!site) return new Response("Not Found", { status: 404 })
const key = new Request(canonical(req.url), req)
let res = await cache.match(key)
if (!res) {
res = await origin.fetch(site.upstream, req)
if (res.ok) ctx.waitUntil(cache.put(key, res.clone()))
}
res.headers.set("x-frontir-pop", region())
return res
}
async function provision(site: Site) {
await dns.upsert(site.domain, { type: "A", value: edgeIp })
await tls.issue(site.domain, { challenge: "dns-01" })
await router.reload()
log.info("provision.ok", { domain: site.domain })
}
// frontir/edge — request router
import { sites, cache, origin } from "@frontir/core"
export async function handle(req: Request): Promise<Response> {
const host = req.headers.get("host") ?? ""
const site = await sites.lookup(host)
if (!site) return new Response("Not Found", { status: 404 })
const key = new Request(canonical(req.url), req)
let res = await cache.match(key)
if (!res) {
res = await origin.fetch(site.upstream, req)
if (res.ok) ctx.waitUntil(cache.put(key, res.clone()))
}
res.headers.set("x-frontir-pop", region())
return res
}
async function provision(site: Site) {
await dns.upsert(site.domain, { type: "A", value: edgeIp })
await tls.issue(site.domain, { challenge: "dns-01" })
await router.reload()
log.info("provision.ok", { domain: site.domain })
}// frontir/edge — request router
import { sites, cache, origin } from "@frontir/core"
export async function handle(req: Request): Promise<Response> {
const host = req.headers.get("host") ?? ""
const site = await sites.lookup(host)
if (!site) return new Response("Not Found", { status: 404 })
const key = new Request(canonical(req.url), req)
let res = await cache.match(key)
if (!res) {
res = await origin.fetch(site.upstream, req)
if (res.ok) ctx.waitUntil(cache.put(key, res.clone()))
}
res.headers.set("x-frontir-pop", region())
return res
}
async function provision(site: Site) {
await dns.upsert(site.domain, { type: "A", value: edgeIp })
await tls.issue(site.domain, { challenge: "dns-01" })
await router.reload()
log.info("provision.ok", { domain: site.domain })
}
// frontir/edge — request router
import { sites, cache, origin } from "@frontir/core"
export async function handle(req: Request): Promise<Response> {
const host = req.headers.get("host") ?? ""
const site = await sites.lookup(host)
if (!site) return new Response("Not Found", { status: 404 })
const key = new Request(canonical(req.url), req)
let res = await cache.match(key)
if (!res) {
res = await origin.fetch(site.upstream, req)
if (res.ok) ctx.waitUntil(cache.put(key, res.clone()))
}
res.headers.set("x-frontir-pop", region())
return res
}
async function provision(site: Site) {
await dns.upsert(site.domain, { type: "A", value: edgeIp })
await tls.issue(site.domain, { challenge: "dns-01" })
await router.reload()
log.info("provision.ok", { domain: site.domain })
}// frontir/edge — request router
import { sites, cache, origin } from "@frontir/core"
export async function handle(req: Request): Promise<Response> {
const host = req.headers.get("host") ?? ""
const site = await sites.lookup(host)
if (!site) return new Response("Not Found", { status: 404 })
const key = new Request(canonical(req.url), req)
let res = await cache.match(key)
if (!res) {
res = await origin.fetch(site.upstream, req)
if (res.ok) ctx.waitUntil(cache.put(key, res.clone()))
}
res.headers.set("x-frontir-pop", region())
return res
}
async function provision(site: Site) {
await dns.upsert(site.domain, { type: "A", value: edgeIp })
await tls.issue(site.domain, { challenge: "dns-01" })
await router.reload()
log.info("provision.ok", { domain: site.domain })
}
// frontir/edge — request router
import { sites, cache, origin } from "@frontir/core"
export async function handle(req: Request): Promise<Response> {
const host = req.headers.get("host") ?? ""
const site = await sites.lookup(host)
if (!site) return new Response("Not Found", { status: 404 })
const key = new Request(canonical(req.url), req)
let res = await cache.match(key)
if (!res) {
res = await origin.fetch(site.upstream, req)
if (res.ok) ctx.waitUntil(cache.put(key, res.clone()))
}
res.headers.set("x-frontir-pop", region())
return res
}
async function provision(site: Site) {
await dns.upsert(site.domain, { type: "A", value: edgeIp })
await tls.issue(site.domain, { challenge: "dns-01" })
await router.reload()
log.info("provision.ok", { domain: site.domain })
}// frontir/edge — request router
import { sites, cache, origin } from "@frontir/core"
export async function handle(req: Request): Promise<Response> {
const host = req.headers.get("host") ?? ""
const site = await sites.lookup(host)
if (!site) return new Response("Not Found", { status: 404 })
const key = new Request(canonical(req.url), req)
let res = await cache.match(key)
if (!res) {
res = await origin.fetch(site.upstream, req)
if (res.ok) ctx.waitUntil(cache.put(key, res.clone()))
}
res.headers.set("x-frontir-pop", region())
return res
}
async function provision(site: Site) {
await dns.upsert(site.domain, { type: "A", value: edgeIp })
await tls.issue(site.domain, { challenge: "dns-01" })
await router.reload()
log.info("provision.ok", { domain: site.domain })
}
// frontir/edge — request router
import { sites, cache, origin } from "@frontir/core"
export async function handle(req: Request): Promise<Response> {
const host = req.headers.get("host") ?? ""
const site = await sites.lookup(host)
if (!site) return new Response("Not Found", { status: 404 })
const key = new Request(canonical(req.url), req)
let res = await cache.match(key)
if (!res) {
res = await origin.fetch(site.upstream, req)
if (res.ok) ctx.waitUntil(cache.put(key, res.clone()))
}
res.headers.set("x-frontir-pop", region())
return res
}
async function provision(site: Site) {
await dns.upsert(site.domain, { type: "A", value: edgeIp })
await tls.issue(site.domain, { challenge: "dns-01" })
await router.reload()
log.info("provision.ok", { domain: site.domain })
}// frontir/edge — request router
import { sites, cache, origin } from "@frontir/core"
export async function handle(req: Request): Promise<Response> {
const host = req.headers.get("host") ?? ""
const site = await sites.lookup(host)
if (!site) return new Response("Not Found", { status: 404 })
const key = new Request(canonical(req.url), req)
let res = await cache.match(key)
if (!res) {
res = await origin.fetch(site.upstream, req)
if (res.ok) ctx.waitUntil(cache.put(key, res.clone()))
}
res.headers.set("x-frontir-pop", region())
return res
}
async function provision(site: Site) {
await dns.upsert(site.domain, { type: "A", value: edgeIp })
await tls.issue(site.domain, { challenge: "dns-01" })
await router.reload()
log.info("provision.ok", { domain: site.domain })
}
// frontir/edge — request router
import { sites, cache, origin } from "@frontir/core"
export async function handle(req: Request): Promise<Response> {
const host = req.headers.get("host") ?? ""
const site = await sites.lookup(host)
if (!site) return new Response("Not Found", { status: 404 })
const key = new Request(canonical(req.url), req)
let res = await cache.match(key)
if (!res) {
res = await origin.fetch(site.upstream, req)
if (res.ok) ctx.waitUntil(cache.put(key, res.clone()))
}
res.headers.set("x-frontir-pop", region())
return res
}
async function provision(site: Site) {
await dns.upsert(site.domain, { type: "A", value: edgeIp })
await tls.issue(site.domain, { challenge: "dns-01" })
await router.reload()
log.info("provision.ok", { domain: site.domain })
}// frontir/edge — request router
import { sites, cache, origin } from "@frontir/core"
export async function handle(req: Request): Promise<Response> {
const host = req.headers.get("host") ?? ""
const site = await sites.lookup(host)
if (!site) return new Response("Not Found", { status: 404 })
const key = new Request(canonical(req.url), req)
let res = await cache.match(key)
if (!res) {
res = await origin.fetch(site.upstream, req)
if (res.ok) ctx.waitUntil(cache.put(key, res.clone()))
}
res.headers.set("x-frontir-pop", region())
return res
}
async function provision(site: Site) {
await dns.upsert(site.domain, { type: "A", value: edgeIp })
await tls.issue(site.domain, { challenge: "dns-01" })
await router.reload()
log.info("provision.ok", { domain: site.domain })
}
// frontir/edge — request router
import { sites, cache, origin } from "@frontir/core"
export async function handle(req: Request): Promise<Response> {
const host = req.headers.get("host") ?? ""
const site = await sites.lookup(host)
if (!site) return new Response("Not Found", { status: 404 })
const key = new Request(canonical(req.url), req)
let res = await cache.match(key)
if (!res) {
res = await origin.fetch(site.upstream, req)
if (res.ok) ctx.waitUntil(cache.put(key, res.clone()))
}
res.headers.set("x-frontir-pop", region())
return res
}
async function provision(site: Site) {
await dns.upsert(site.domain, { type: "A", value: edgeIp })
await tls.issue(site.domain, { challenge: "dns-01" })
await router.reload()
log.info("provision.ok", { domain: site.domain })
}// frontir/edge — request router
import { sites, cache, origin } from "@frontir/core"
export async function handle(req: Request): Promise<Response> {
const host = req.headers.get("host") ?? ""
const site = await sites.lookup(host)
if (!site) return new Response("Not Found", { status: 404 })
const key = new Request(canonical(req.url), req)
let res = await cache.match(key)
if (!res) {
res = await origin.fetch(site.upstream, req)
if (res.ok) ctx.waitUntil(cache.put(key, res.clone()))
}
res.headers.set("x-frontir-pop", region())
return res
}
async function provision(site: Site) {
await dns.upsert(site.domain, { type: "A", value: edgeIp })
await tls.issue(site.domain, { challenge: "dns-01" })
await router.reload()
log.info("provision.ok", { domain: site.domain })
}
// frontir/edge — request router
import { sites, cache, origin } from "@frontir/core"
export async function handle(req: Request): Promise<Response> {
const host = req.headers.get("host") ?? ""
const site = await sites.lookup(host)
if (!site) return new Response("Not Found", { status: 404 })
const key = new Request(canonical(req.url), req)
let res = await cache.match(key)
if (!res) {
res = await origin.fetch(site.upstream, req)
if (res.ok) ctx.waitUntil(cache.put(key, res.clone()))
}
res.headers.set("x-frontir-pop", region())
return res
}
async function provision(site: Site) {
await dns.upsert(site.domain, { type: "A", value: edgeIp })
await tls.issue(site.domain, { challenge: "dns-01" })
await router.reload()
log.info("provision.ok", { domain: site.domain })
}Request, review, follow-up, automatic. The loop that grows your reputation while you run the business.
WePaint Cabinets
Kyle Bishop · Owner
“Our whole model is follow-up. We bring the booth to the driveway, restore the kitchen on site, then check back while it cures. Frontir sends the request the moment we wrap and routes anything private to us first.”
Frontir Solutions
One company.
A family of Frontir products.
Frontir Solutions builds and operates a growing family of independent brands, each run to one standard, by one North American team.
// frontir/edge — request router
import { sites, cache, origin } from "@frontir/core"
export async function handle(req: Request): Promise<Response> {
const host = req.headers.get("host") ?? ""
const site = await sites.lookup(host)
if (!site) return new Response("Not Found", { status: 404 })
const key = new Request(canonical(req.url), req)
let res = await cache.match(key)
if (!res) {
res = await origin.fetch(site.upstream, req)
if (res.ok) ctx.waitUntil(cache.put(key, res.clone()))
}
res.headers.set("x-frontir-pop", region())
return res
}
async function provision(site: Site) {
await dns.upsert(site.domain, { type: "A", value: edgeIp })
await tls.issue(site.domain, { challenge: "dns-01" })
await router.reload()
log.info("provision.ok", { domain: site.domain })
}
// frontir/edge — request router
import { sites, cache, origin } from "@frontir/core"
export async function handle(req: Request): Promise<Response> {
const host = req.headers.get("host") ?? ""
const site = await sites.lookup(host)
if (!site) return new Response("Not Found", { status: 404 })
const key = new Request(canonical(req.url), req)
let res = await cache.match(key)
if (!res) {
res = await origin.fetch(site.upstream, req)
if (res.ok) ctx.waitUntil(cache.put(key, res.clone()))
}
res.headers.set("x-frontir-pop", region())
return res
}
async function provision(site: Site) {
await dns.upsert(site.domain, { type: "A", value: edgeIp })
await tls.issue(site.domain, { challenge: "dns-01" })
await router.reload()
log.info("provision.ok", { domain: site.domain })
}// frontir/edge — request router
import { sites, cache, origin } from "@frontir/core"
export async function handle(req: Request): Promise<Response> {
const host = req.headers.get("host") ?? ""
const site = await sites.lookup(host)
if (!site) return new Response("Not Found", { status: 404 })
const key = new Request(canonical(req.url), req)
let res = await cache.match(key)
if (!res) {
res = await origin.fetch(site.upstream, req)
if (res.ok) ctx.waitUntil(cache.put(key, res.clone()))
}
res.headers.set("x-frontir-pop", region())
return res
}
async function provision(site: Site) {
await dns.upsert(site.domain, { type: "A", value: edgeIp })
await tls.issue(site.domain, { challenge: "dns-01" })
await router.reload()
log.info("provision.ok", { domain: site.domain })
}
// frontir/edge — request router
import { sites, cache, origin } from "@frontir/core"
export async function handle(req: Request): Promise<Response> {
const host = req.headers.get("host") ?? ""
const site = await sites.lookup(host)
if (!site) return new Response("Not Found", { status: 404 })
const key = new Request(canonical(req.url), req)
let res = await cache.match(key)
if (!res) {
res = await origin.fetch(site.upstream, req)
if (res.ok) ctx.waitUntil(cache.put(key, res.clone()))
}
res.headers.set("x-frontir-pop", region())
return res
}
async function provision(site: Site) {
await dns.upsert(site.domain, { type: "A", value: edgeIp })
await tls.issue(site.domain, { challenge: "dns-01" })
await router.reload()
log.info("provision.ok", { domain: site.domain })
}// frontir/edge — request router
import { sites, cache, origin } from "@frontir/core"
export async function handle(req: Request): Promise<Response> {
const host = req.headers.get("host") ?? ""
const site = await sites.lookup(host)
if (!site) return new Response("Not Found", { status: 404 })
const key = new Request(canonical(req.url), req)
let res = await cache.match(key)
if (!res) {
res = await origin.fetch(site.upstream, req)
if (res.ok) ctx.waitUntil(cache.put(key, res.clone()))
}
res.headers.set("x-frontir-pop", region())
return res
}
async function provision(site: Site) {
await dns.upsert(site.domain, { type: "A", value: edgeIp })
await tls.issue(site.domain, { challenge: "dns-01" })
await router.reload()
log.info("provision.ok", { domain: site.domain })
}
// frontir/edge — request router
import { sites, cache, origin } from "@frontir/core"
export async function handle(req: Request): Promise<Response> {
const host = req.headers.get("host") ?? ""
const site = await sites.lookup(host)
if (!site) return new Response("Not Found", { status: 404 })
const key = new Request(canonical(req.url), req)
let res = await cache.match(key)
if (!res) {
res = await origin.fetch(site.upstream, req)
if (res.ok) ctx.waitUntil(cache.put(key, res.clone()))
}
res.headers.set("x-frontir-pop", region())
return res
}
async function provision(site: Site) {
await dns.upsert(site.domain, { type: "A", value: edgeIp })
await tls.issue(site.domain, { challenge: "dns-01" })
await router.reload()
log.info("provision.ok", { domain: site.domain })
}// frontir/edge — request router
import { sites, cache, origin } from "@frontir/core"
export async function handle(req: Request): Promise<Response> {
const host = req.headers.get("host") ?? ""
const site = await sites.lookup(host)
if (!site) return new Response("Not Found", { status: 404 })
const key = new Request(canonical(req.url), req)
let res = await cache.match(key)
if (!res) {
res = await origin.fetch(site.upstream, req)
if (res.ok) ctx.waitUntil(cache.put(key, res.clone()))
}
res.headers.set("x-frontir-pop", region())
return res
}
async function provision(site: Site) {
await dns.upsert(site.domain, { type: "A", value: edgeIp })
await tls.issue(site.domain, { challenge: "dns-01" })
await router.reload()
log.info("provision.ok", { domain: site.domain })
}
// frontir/edge — request router
import { sites, cache, origin } from "@frontir/core"
export async function handle(req: Request): Promise<Response> {
const host = req.headers.get("host") ?? ""
const site = await sites.lookup(host)
if (!site) return new Response("Not Found", { status: 404 })
const key = new Request(canonical(req.url), req)
let res = await cache.match(key)
if (!res) {
res = await origin.fetch(site.upstream, req)
if (res.ok) ctx.waitUntil(cache.put(key, res.clone()))
}
res.headers.set("x-frontir-pop", region())
return res
}
async function provision(site: Site) {
await dns.upsert(site.domain, { type: "A", value: edgeIp })
await tls.issue(site.domain, { challenge: "dns-01" })
await router.reload()
log.info("provision.ok", { domain: site.domain })
}// frontir/edge — request router
import { sites, cache, origin } from "@frontir/core"
export async function handle(req: Request): Promise<Response> {
const host = req.headers.get("host") ?? ""
const site = await sites.lookup(host)
if (!site) return new Response("Not Found", { status: 404 })
const key = new Request(canonical(req.url), req)
let res = await cache.match(key)
if (!res) {
res = await origin.fetch(site.upstream, req)
if (res.ok) ctx.waitUntil(cache.put(key, res.clone()))
}
res.headers.set("x-frontir-pop", region())
return res
}
async function provision(site: Site) {
await dns.upsert(site.domain, { type: "A", value: edgeIp })
await tls.issue(site.domain, { challenge: "dns-01" })
await router.reload()
log.info("provision.ok", { domain: site.domain })
}
// frontir/edge — request router
import { sites, cache, origin } from "@frontir/core"
export async function handle(req: Request): Promise<Response> {
const host = req.headers.get("host") ?? ""
const site = await sites.lookup(host)
if (!site) return new Response("Not Found", { status: 404 })
const key = new Request(canonical(req.url), req)
let res = await cache.match(key)
if (!res) {
res = await origin.fetch(site.upstream, req)
if (res.ok) ctx.waitUntil(cache.put(key, res.clone()))
}
res.headers.set("x-frontir-pop", region())
return res
}
async function provision(site: Site) {
await dns.upsert(site.domain, { type: "A", value: edgeIp })
await tls.issue(site.domain, { challenge: "dns-01" })
await router.reload()
log.info("provision.ok", { domain: site.domain })
}// frontir/edge — request router
import { sites, cache, origin } from "@frontir/core"
export async function handle(req: Request): Promise<Response> {
const host = req.headers.get("host") ?? ""
const site = await sites.lookup(host)
if (!site) return new Response("Not Found", { status: 404 })
const key = new Request(canonical(req.url), req)
let res = await cache.match(key)
if (!res) {
res = await origin.fetch(site.upstream, req)
if (res.ok) ctx.waitUntil(cache.put(key, res.clone()))
}
res.headers.set("x-frontir-pop", region())
return res
}
async function provision(site: Site) {
await dns.upsert(site.domain, { type: "A", value: edgeIp })
await tls.issue(site.domain, { challenge: "dns-01" })
await router.reload()
log.info("provision.ok", { domain: site.domain })
}
// frontir/edge — request router
import { sites, cache, origin } from "@frontir/core"
export async function handle(req: Request): Promise<Response> {
const host = req.headers.get("host") ?? ""
const site = await sites.lookup(host)
if (!site) return new Response("Not Found", { status: 404 })
const key = new Request(canonical(req.url), req)
let res = await cache.match(key)
if (!res) {
res = await origin.fetch(site.upstream, req)
if (res.ok) ctx.waitUntil(cache.put(key, res.clone()))
}
res.headers.set("x-frontir-pop", region())
return res
}
async function provision(site: Site) {
await dns.upsert(site.domain, { type: "A", value: edgeIp })
await tls.issue(site.domain, { challenge: "dns-01" })
await router.reload()
log.info("provision.ok", { domain: site.domain })
}// frontir/edge — request router
import { sites, cache, origin } from "@frontir/core"
export async function handle(req: Request): Promise<Response> {
const host = req.headers.get("host") ?? ""
const site = await sites.lookup(host)
if (!site) return new Response("Not Found", { status: 404 })
const key = new Request(canonical(req.url), req)
let res = await cache.match(key)
if (!res) {
res = await origin.fetch(site.upstream, req)
if (res.ok) ctx.waitUntil(cache.put(key, res.clone()))
}
res.headers.set("x-frontir-pop", region())
return res
}
async function provision(site: Site) {
await dns.upsert(site.domain, { type: "A", value: edgeIp })
await tls.issue(site.domain, { challenge: "dns-01" })
await router.reload()
log.info("provision.ok", { domain: site.domain })
}
// frontir/edge — request router
import { sites, cache, origin } from "@frontir/core"
export async function handle(req: Request): Promise<Response> {
const host = req.headers.get("host") ?? ""
const site = await sites.lookup(host)
if (!site) return new Response("Not Found", { status: 404 })
const key = new Request(canonical(req.url), req)
let res = await cache.match(key)
if (!res) {
res = await origin.fetch(site.upstream, req)
if (res.ok) ctx.waitUntil(cache.put(key, res.clone()))
}
res.headers.set("x-frontir-pop", region())
return res
}
async function provision(site: Site) {
await dns.upsert(site.domain, { type: "A", value: edgeIp })
await tls.issue(site.domain, { challenge: "dns-01" })
await router.reload()
log.info("provision.ok", { domain: site.domain })
}Line of business // 01
Frontir
Hosting
Sites, Servers & Community Infrastructure
Reviewed-path hosting for websites, domains, game servers, and community infrastructure.
- Websites, Domains, and DNS
- Game Servers and Community Infrastructure
- One Reviewed Path from Request to Live
Line of business // 02
Frontir
Reviews
Reviews & Reputation Management
A reputation platform built around one seamless loop: request the review, capture it, and follow up, automatically. Businesses collect and route feedback, recover unhappy customers in a private inbox, and grow their rating with embeddable widgets and reporting across one multi-tenant system.
- Automatic Request, Review & Follow-up Loop
- Private Feedback & Service Recovery
- Widgets, Reports & Multi-location
Request, review, follow-up, automatic. The loop that grows your reputation while you run the business.
WePaint Cabinets
Kyle Bishop · Owner
“Our whole model is follow-up. We bring the booth to the driveway, restore the kitchen on site, then check back while it cures. Frontir sends the request the moment we wrap and routes anything private to us first.”
Sarah Whitfield
Cabinet Refinishing
“They rolled the booth right up to the house and did it all on site. No crews in and out, and the kitchen was spotless when they left. The cabinets look better than new.”
Line of business // 03
Frontir
Horizon
Emergency Operations Platform
A web-based emergency operations platform that bridges the systems agencies already run into one shared operating picture. First responders manage incidents, track personnel and assets, and coordinate resources across every hazard, all in one place.
- Shared Common Operating Picture
- Incident, Personnel & Asset Tracking
- Resource Coordination & Weather Awareness
Warehouse Fire · NW Commerce Dr
INC-1001 · Structure fire
Engine 4
On scene
Cardiac Arrest · Maple & 3rd
EMS-2207 · Medical
Medic 2
En route
Multi-Vehicle Crash · US-50
INC-1002 · Vehicle crash
Patrol 7
Stabilizing
Tornado Warning · Jackson County
WX-0444 · Severe weather
EM Ops
Active
More to come
We’re a company that builds. New Frontir lines of business are always in the works. Bring the problem; we bring the team that builds and operates it, held to the same standard as everything else.
Start a Conversation