@jimhoyd/urlcode 0.3.0

package/dist/types/observability.d.ts

@@ -0,0 +1,104 @@
+export declare const events: Readonly<{
+    request: readonly string[];
+    reload: readonly string[];
+    watch: readonly string[];
+    function_worker: readonly string[];
+    link_store_worker: readonly string[];
+    link_request: readonly string[];
+    link_observer: readonly string[];
+    logs_dropped: readonly string[];
+    observer: readonly string[];
+    management_request: readonly string[];
+    throttle: readonly string[];
+    agents: readonly string[];
+    cache: readonly string[];
+    listening: readonly string[];
+}>;
+/** One log record: a flat object whose `event` key names the kind (see `events`). */
+export type ObserverEvent = Record<string, unknown>;
+export interface Observer {
+    name: string;
+    version: string;
+    onEvent?(event: ObserverEvent): unknown;
+    onMetrics?(snapshot: MetricsSnapshot): unknown;
+    onClose?(): unknown;
+}
+/** What the event does not say: the route when the request log is minimal, and whether this was a probe. */
+export interface RecordContext {
+    probe?: boolean;
+    route?: string;
+}
+type Counters = Record<string, number>;
+export interface MetricsSnapshot {
+    version: number;
+    uptimeSeconds: number;
+    rssBytes: number;
+    requests: {
+        total: number;
+        byStatusClass: Counters;
+        inFlight: number;
+        byRoute: Counters;
+    };
+    health: {
+        total: number;
+        byStatusClass: Counters;
+        inFlight: number;
+    };
+    shed: {
+        requests: number;
+        health: number;
+    };
+    reloads: {
+        ok: number;
+        rejected: number;
+    };
+    watch: {
+        failed: number;
+    };
+    functionWorkers: {
+        started: number;
+        restarts: number;
+        healthySlots: number;
+        slots: number;
+    };
+    linkStoreWorkers: {
+        started: number;
+        restarts: number;
+    };
+    policies: {
+        throttle: Counters;
+        agents: Counters;
+        cache: Counters;
+    };
+    linkRequests: Counters;
+    linkObserver: {
+        failed: number;
+        dropped: number;
+    };
+    logsDropped: number;
+    observers: {
+        errors: number;
+    };
+    [extra: string]: unknown;
+}
+export interface Metrics {
+    record(event: unknown, context?: RecordContext): void;
+    inFlight(kind: string, delta: number): void;
+    shed(kind: string): void;
+    observerError(): void;
+    snapshot(extra?: Record<string, unknown>): MetricsSnapshot;
+}
+/** The log sink the runtime writes to: callable like a logger, with the counters and observers hanging off it. */
+export type ObserverSink = ((event: ObserverEvent, context?: RecordContext) => void) & {
+    fail(observer: Observer): void;
+    metrics: Metrics;
+    observers: Observer[];
+    publish(snapshot: MetricsSnapshot): void;
+    close(): Promise<void>;
+};
+export declare function validateObservers(observers?: unknown): Observer[];
+export declare const SNAPSHOT_VERSION = 1;
+export declare function createMetrics(): Metrics;
+export declare function createObserverSink(observers?: unknown, fallbackLog?: (event: ObserverEvent) => void, metrics?: Metrics): ObserverSink;
+export declare function renderPrometheus(snapshot: Partial<MetricsSnapshot>): string;
+export {};

package/dist/types/plugins.d.ts

@@ -0,0 +1,27 @@
+import type { HandlerResult } from './http-response.ts';
+import type { PolicyRequest, TargetName, TestPlan } from './types.ts';
+export type { PolicyRequest, TargetName, TestPlan } from './types.ts';
+export type { HandlerResult, HeaderPair } from './http-response.ts';
+/** What onActivate receives: the started runtime's public facts, never its handlers. */
+export interface PluginRuntime {
+    testPlan(): TestPlan;
+    version: string;
+    root: string;
+    target: string;
+}
+export interface Plugin {
+    name: string;
+    version: string;
+    targets: TargetName[];
+    onActivate?(runtime: PluginRuntime): void | Promise<void>;
+    onRequest?(request: PolicyRequest): HandlerResult | undefined | void | Promise<HandlerResult | undefined | void>;
+    onResponse?(request: PolicyRequest, result: HandlerResult): HandlerResult | undefined | void | Promise<HandlerResult | undefined | void>;
+    onError?(request: PolicyRequest, error: unknown): void | Promise<void>;
+    onClose?(): void | Promise<void>;
+}
+export declare function validatePlugins(plugins?: unknown, target?: string): Plugin[];
+export declare function activatePlugins(plugins: Plugin[], runtime: PluginRuntime): Promise<void>;
+export declare function pluginsRequest(plugins: Plugin[], request: PolicyRequest): Promise<HandlerResult | undefined>;
+export declare function pluginsResponse(plugins: Plugin[], request: PolicyRequest, result: HandlerResult): Promise<HandlerResult>;
+export declare function pluginsError(plugins: Plugin[], request: PolicyRequest, error: unknown): Promise<void>;
+export declare function closePlugins(plugins: Plugin[]): Promise<void>;

package/dist/types/policies/agents.d.ts

@@ -0,0 +1,86 @@
+import type { HandlerResult } from '../http-response.ts';
+export declare const name = "agents";
+export declare const phases: readonly string[];
+export declare function targets(): Record<string, 'native' | 'compiled'>;
+export interface AgentEntry {
+    name?: string;
+    pattern: string;
+}
+export interface AgentsConfig {
+    mode?: 'enforce' | 'report';
+    status?: number;
+    denyEmpty?: boolean;
+    deny?: string[];
+    allow?: string[];
+    denyPatterns?: string[];
+    allowPatterns?: string[];
+    /** Project list files attached by the Cloudflare build, keyed by reference. */
+    resolved?: Record<string, AgentEntry[]>;
+}
+type Log = (event: Record<string, unknown>) => void;
+export interface PolicyContext {
+    route: {
+        pattern: string;
+    };
+    shared?: {
+        log?: Log;
+    };
+    target?: string;
+    root?: string;
+}
+interface CompiledList {
+    label: string;
+    count: number;
+    regexp: RegExp;
+}
+interface ListUse {
+    name: string;
+    patterns: number;
+    source: string;
+    revision: string;
+}
+export interface AgentsState {
+    route: string;
+    mode: 'enforce' | 'report';
+    status: number;
+    denyEmpty: boolean;
+    deny: CompiledList[];
+    allow: CompiledList[];
+    used: {
+        deny: ListUse[];
+        allow: ListUse[];
+    };
+    patternCounts: {
+        deny: number;
+        allow: number;
+    };
+    log: Log | undefined;
+}
+export interface AgentsDescription {
+    mode: 'enforce' | 'report';
+    status: number;
+    denyEmpty: boolean;
+    deny: ListUse[];
+    allow: ListUse[];
+    denyPatterns: number;
+    allowPatterns: number;
+    patterns: {
+        deny: number;
+        allow: number;
+    };
+}
+export declare const bundledLists: readonly string[];
+export declare const MAX_PATTERN_BYTES = 256;
+export declare const MAX_REPEAT = 64;
+export declare function validatePattern(pattern: unknown): string | undefined;
+export declare function isBundled(reference: string): boolean;
+export declare function isListFile(reference: unknown): reference is string;
+export declare function compile(config: AgentsConfig | undefined, context: PolicyContext): AgentsState | Promise<AgentsState>;
+export declare function onRequest(state: AgentsState, request: {
+    headers: {
+        get(name: string): string | null;
+    };
+}): HandlerResult | undefined;
+export declare function describe(state: AgentsState): AgentsDescription;
+export declare function close(): Promise<void>;
+export {};

package/dist/types/policies/cache.d.ts

@@ -0,0 +1,82 @@
+import type { HandlerResult, HeaderPair } from '../http-response.ts';
+import type { LogFn, PolicyContext, PolicyRequest, PolicyShared, PolicySupport, TargetName } from '../types.ts';
+export declare const name = "cache";
+export declare const phases: readonly string[];
+export type Strategy = 'no-store' | 'revalidate' | 'public' | 'immutable' | 'swr' | 'sie' | 'micro' | 'cdn-only' | 'private';
+export interface CacheConfig {
+    strategy: Strategy;
+    maxAge?: number;
+    staleWhileRevalidate?: number;
+    staleIfError?: number;
+    cdnMaxAge?: number;
+    originTtl?: number;
+    vary?: string[];
+    statuses?: number[];
+    maxBytes?: number;
+    maxEntries?: number;
+    force?: boolean;
+}
+/** A stored 200 representation: the result minus its body and headers, which are kept separately. */
+export interface CacheEntry {
+    result: Omit<HandlerResult, 'body' | 'headers'>;
+    headers: HeaderPair[];
+    body: Buffer;
+    storedAt: number;
+    revalidating: boolean;
+}
+/** The in-flight fill for one key; waiters share its promise up to MAX_WAITERS. */
+export interface Flight {
+    waiters: number;
+    promise: Promise<CacheEntry | null>;
+    resolve: (entry: CacheEntry | null) => void;
+    reject: (error: Error) => void;
+}
+/** The one origin cache per runtime, shared by every route with an origin-caching strategy. */
+export interface CacheStore {
+    entries: Map<string, CacheEntry>;
+    pending: Map<string, Flight>;
+    bytes: number;
+    maxBytes: number;
+    now: () => number;
+}
+export interface CacheState {
+    strategy: Strategy;
+    cacheControl: string;
+    cdnCacheControl: string | undefined;
+    vary: string[];
+    statuses: Set<number>;
+    maxBytes: number;
+    maxEntries: number;
+    origin: boolean;
+    freshMs: number;
+    staleMs: number;
+    originTtl: number | null;
+    staleIfError: number | null;
+    route: string;
+    secrets: boolean;
+    log: LogFn | undefined;
+    store: CacheStore;
+    yamlCacheControl: boolean;
+    inheritedAsset: boolean;
+    inflight: WeakMap<object, {
+        key: string;
+        flight: Flight;
+    }>;
+}
+export interface CacheDescription {
+    strategy: Strategy;
+    cacheControl: string;
+    origin: boolean;
+    originTtl: number | null;
+    vary: string[];
+    cdnCacheControl?: string;
+    staleWhileRevalidate?: number;
+    staleIfError?: number;
+}
+export declare function targets(): Record<TargetName, PolicySupport>;
+export declare function compile(config: CacheConfig, { route, shared }: PolicyContext): Promise<CacheState>;
+export declare function onRequest(state: CacheState, req: PolicyRequest): Promise<HandlerResult | undefined>;
+export declare function onResponse(state: CacheState, req: PolicyRequest, result: HandlerResult): HandlerResult;
+export declare function onError(state: CacheState, req: PolicyRequest, _error?: unknown): void;
+export declare function describe(state: CacheState): CacheDescription;
+export declare function close(shared: PolicyShared | undefined): Promise<void>;

package/dist/types/policies/compression.d.ts

@@ -0,0 +1,41 @@
+import type { HandlerResult } from '../http-response.ts';
+import type { AssetResult, PolicyContext, PolicyRequest, PolicyShared, PolicySupport, TargetName } from '../types.ts';
+export declare const name = "compression";
+export declare const phases: readonly string[];
+export type Coding = 'br' | 'gzip' | 'deflate' | 'zstd';
+export interface CompressionConfig {
+    encodings?: Coding[];
+    minBytes?: number;
+    types?: string[];
+    level?: number;
+    allowWithSecrets?: boolean;
+}
+interface Levels {
+    dynamic: number;
+    stored: number;
+}
+export interface CompressionState {
+    encodings: Coding[];
+    minBytes: number;
+    types: string[];
+    matches: (header: string | undefined) => boolean;
+    level: number | null;
+    levels: Partial<Record<Coding, Levels>>;
+    allowWithSecrets: boolean;
+    precompressed: number;
+}
+export interface CompressionDescription {
+    encodings: Coding[];
+    minBytes: number;
+    types: number;
+    level: number | null;
+    precompressed: number;
+}
+export declare const zstdAvailable: boolean;
+export declare function targets(): Record<TargetName, PolicySupport>;
+export declare function compile(config: CompressionConfig, { route, shared }: PolicyContext): Promise<CompressionState>;
+export declare function negotiate<C extends string>(acceptEncoding: string | null | undefined, encodings: readonly C[]): C | null;
+export declare function onResponse(state: CompressionState, request: PolicyRequest, result: AssetResult): HandlerResult;
+export declare function describe(state: CompressionState): CompressionDescription;
+export declare function close(shared: PolicyShared | undefined): Promise<void>;
+export {};

package/dist/types/policies/security.d.ts

@@ -0,0 +1,37 @@
+import type { HandlerResult, HeaderPair } from '../http-response.ts';
+export interface SecurityConfig {
+    headers?: string;
+    unset?: string[];
+    set?: Record<string, string>;
+}
+export interface SecurityState {
+    profileName: string;
+    profile: readonly HeaderPair[];
+    overrides: readonly HeaderPair[];
+    size: number;
+    unset: readonly string[];
+    overrideKeys: Set<string>;
+}
+export interface SecurityDescription {
+    headers: string;
+    emits: string[];
+    set: string[];
+    unset: string[];
+    bytes: number;
+}
+export declare const name = "security";
+export declare const phases: readonly string[];
+export declare const oshpRevision = "OSHP 2024 best practices";
+export declare const profiles: Readonly<Record<string, readonly (readonly [string, string])[]>>;
+export declare const reservedHeaders: Readonly<Set<string>>;
+export declare function targets(): Record<string, 'native' | 'compiled'>;
+export declare function compile(config: unknown, { route }: {
+    route: {
+        pattern: string;
+    };
+}): SecurityState;
+export declare function onResponse(state: SecurityState, request: {
+    origin?: unknown;
+} | null | undefined, result: HandlerResult): HandlerResult;
+export declare function describe(state: SecurityState): SecurityDescription;
+export declare function close(): void;

package/dist/types/policies/throttle.d.ts

@@ -0,0 +1,55 @@
+import type { HandlerResult } from '../http-response.ts';
+import type { LogFn, PolicyContext, PolicyRequest, PolicyShared, PolicySupport, TargetName } from '../types.ts';
+export declare const name = "throttle";
+export declare const phases: readonly string[];
+export type Partition = 'client' | 'route' | 'client-route';
+export interface ThrottleConfig {
+    quota: number;
+    window: number;
+    partition?: Partition;
+    status?: number;
+    mode?: 'enforce' | 'report';
+    maxKeys?: number;
+}
+interface Entry {
+    start: number;
+    current: number;
+    previous: number;
+}
+/** The one counter table per runtime, shared by every route that declares a throttle. */
+export interface ThrottleTable {
+    keys: Map<string, Entry>;
+    maxKeys: number;
+    now: () => number;
+}
+interface Budget {
+    remaining: number;
+    reset: number;
+}
+export interface ThrottleState {
+    quota: number;
+    window: number;
+    windowMs: number;
+    partition: Partition;
+    status: number;
+    mode: 'enforce' | 'report';
+    route: string;
+    table: ThrottleTable;
+    log: LogFn | undefined;
+    pending: WeakMap<object, Budget>;
+}
+export interface ThrottleDescription {
+    quota: number;
+    window: number;
+    partition: Partition;
+    mode: 'enforce' | 'report';
+    status: number;
+    unresolvedClient?: string;
+}
+export declare function targets(config?: Partial<ThrottleConfig>): Record<TargetName, PolicySupport>;
+export declare function compile(config: ThrottleConfig, { route, shared }: PolicyContext): Promise<ThrottleState>;
+export declare function onRequest(state: ThrottleState, req: PolicyRequest): Promise<HandlerResult | undefined>;
+export declare function onResponse(state: ThrottleState, req: PolicyRequest, result: HandlerResult): HandlerResult;
+export declare function describe(state: ThrottleState): ThrottleDescription;
+export declare function close(shared: PolicyShared): Promise<void>;
+export {};

package/dist/types/policies.d.ts

@@ -0,0 +1,36 @@
+import type { HeaderPair } from './http-response.ts';
+import type { SecurityState } from './policies/security.ts';
+import type { EffectivePolicies, PolicyChain, PolicyConfigs, PolicyContext, PolicyDescriptions, PolicyLayer, PolicyModule, PolicyName, PolicyRequest, PolicyShared, PolicyStates, ProjectDocument, RouteConfig, TargetName } from './types.ts';
+export type { PolicyChain, PolicyContext, PolicyModule, PolicyRequest, PolicyShared } from './types.ts';
+/** The registry, typed per policy so `registry.cache.compile` returns a CacheState; erased to PolicyModule where iterated. */
+export type PolicyRegistry = {
+    [K in PolicyName]: PolicyModule<PolicyConfigs[K], PolicyStates[K], PolicyDescriptions[K]>;
+};
+export declare const registry: PolicyRegistry;
+export declare const requestOrder: readonly PolicyName[];
+export declare const responseOrder: readonly PolicyName[];
+export declare const targets: readonly TargetName[];
+export declare const builtinProfiles: Readonly<Record<string, PolicyLayer>>;
+export declare function effectivePolicies(document: ProjectDocument, routeConfig: Pick<RouteConfig, 'policies'> | undefined): EffectivePolicies;
+export declare function compilePolicies(document: ProjectDocument, routeConfig: Pick<RouteConfig, 'policies'> | undefined, { route, shared, target, root }: PolicyContext): Promise<PolicyChain>;
+export declare function compileErrorPolicy(document: ProjectDocument, { target }?: {
+    target?: TargetName;
+}): SecurityState | null;
+export declare function errorHeaders(state: SecurityState | null | undefined, origin: string | undefined): HeaderPair[];
+export declare function closePolicies(shared: PolicyShared): Promise<void>;
+export interface PolicyRequestInput {
+    method: string;
+    target: string;
+    path: string;
+    params?: Record<string, string>;
+    query: URLSearchParams;
+    headers: PolicyRequest['headers'];
+    headerCounts?: Record<string, number> | undefined;
+    client?: string | null | undefined;
+    origin?: string | undefined;
+    route: {
+        pattern: string;
+        secrets?: Record<string, string>;
+    };
+}
+export declare function policyRequest({ method, target, path, params, query, headers, headerCounts, client, origin, route }: PolicyRequestInput): PolicyRequest;

package/dist/types/policy.d.ts

@@ -0,0 +1,21 @@
+import type { FunctionSources } from './function-sources.ts';
+import type { LoadedDocument } from './types.ts';
+/** The operator's binding grants: which env and secret names each route may read, pinned to a project hash. */
+export interface OperatorPolicy {
+    version: 1;
+    projectSha256: string;
+    routes: Record<string, {
+        env?: string[];
+        secrets?: string[];
+    }>;
+}
+/** The function snapshot plus the hash operator grants are pinned to. */
+export interface FunctionSnapshot extends FunctionSources {
+    projectSha256: string;
+}
+export declare function prepareFunctionSnapshot(loaded: LoadedDocument): Promise<FunctionSnapshot>;
+export declare function validatePolicy(value: unknown): OperatorPolicy;
+export declare function loadOperatorPolicy(file: string | undefined, project: string): Promise<OperatorPolicy | undefined>;
+export declare function requestedPermissions(loaded: LoadedDocument, snapshot: {
+    projectSha256: string;
+}): OperatorPolicy;

package/dist/types/prerender.d.ts

@@ -0,0 +1,31 @@
+import type { RouteInventory, RequestCase } from './readiness.ts';
+import type { LogFn } from './types.ts';
+export interface NativeProjectOptions {
+    allow?: string[] | undefined;
+    log?: LogFn | undefined;
+}
+export interface PrerenderOptions {
+    origin?: string | undefined;
+    fileName?: ((path: string) => string) | undefined;
+    ignoreUnrenderable?: boolean | undefined;
+    maxPages?: number | undefined;
+    maxPageBytes?: number | undefined;
+    maxTotalBytes?: number | undefined;
+    log?: LogFn | undefined;
+}
+export interface PrerenderedPage {
+    path: string;
+    file: string;
+    bytes: number;
+}
+export interface PrerenderReport {
+    count: number;
+    bytes: number;
+    directory: string;
+    pages: PrerenderedPage[];
+    fixtures: RequestCase[];
+}
+export declare function assertLiteralRoutePath(path: string): string[];
+export declare function pageFileName(path: string): string;
+export declare function assertNativeProject(project: string, { allow, log }?: NativeProjectOptions): Promise<RouteInventory[]>;
+export declare function prerenderPages(project: string, output: string, { origin, fileName, ignoreUnrenderable, maxPages, maxPageBytes, maxTotalBytes, log, }?: PrerenderOptions): Promise<PrerenderReport>;

package/dist/types/project-tests.d.ts

@@ -0,0 +1,13 @@
+import type { ServerOptions } from './server.ts';
+import type { LogFn } from './types.ts';
+export interface ProjectTestOptions {
+    log?: LogFn | undefined;
+    permissions?: ServerOptions['permissions'];
+    linkStore?: ServerOptions['linkStore'];
+    origin?: string | undefined;
+}
+export interface ProjectTestResult {
+    total: number;
+    failed: number;
+}
+export declare function runProjectTests(project: string, { log, permissions, linkStore, origin }?: ProjectTestOptions): Promise<ProjectTestResult>;

package/dist/types/readiness.d.ts

@@ -0,0 +1,121 @@
+import { Agent } from 'node:http';
+import type { AddressInfo } from 'node:net';
+import type { CompiledRedirect, CompiledRoute, LogFn, PlanInventoryEntry, PolicyInventory } from './types.ts';
+import type { ComplianceOptions, ComplianceReport } from './compliance.ts';
+import type { CompiledRoutes } from './match.ts';
+export type { RouteState } from './types.ts';
+export type HandlerName = 'redirect' | 'function' | 'page' | 'static' | 'download' | 'respond' | 'link';
+/** One configured route as the inventory reports it: a PlanInventoryEntry with the handler kind named. */
+export interface RouteInventory extends PlanInventoryEntry {
+    handler: HandlerName | undefined;
+}
+/** One request case: a generated probe or a `tests/requests.json` fixture. */
+export interface RequestCase {
+    path: string;
+    method?: string | undefined;
+    status: number;
+    headers?: Record<string, string> | undefined;
+    body?: string | undefined;
+    expectHeaders?: Record<string, string> | undefined;
+    expectBody?: string | undefined;
+}
+export interface ProjectPlan {
+    inventory: RouteInventory[];
+    cases: RequestCase[];
+    resolve: (path: string) => string | undefined;
+}
+export interface HitResult {
+    pass: boolean;
+    status: number;
+    durationMs: number;
+    error?: string;
+}
+export interface BenchmarkTarget {
+    protocol: string;
+    hostname: string;
+    port: number | string;
+}
+/** A started server as the audit and benchmark see it. structural: the real type is startServer's result in src/server.ts. */
+export interface AuditableApp {
+    address: AddressInfo;
+    root: string;
+    testPlan(): ProjectPlan & {
+        dynamicLinks?: boolean;
+        policies?: Record<string, PolicyInventory>;
+    };
+}
+export type { ComplianceOptions, ComplianceReport } from './compliance.ts';
+export interface AuditOptions {
+    expectRoutes?: number | undefined;
+    log?: LogFn | undefined;
+    compliance?: ComplianceOptions | undefined;
+}
+export interface AuditReport {
+    dynamicLinks: boolean | undefined;
+    elapsedMs: number;
+    ready: boolean;
+    counts: {
+        configured: number;
+        active: number;
+        disabled: number;
+        expired: number;
+        byHandler: Record<string, number>;
+    };
+    expectedRoutes: number | null;
+    countMatches: boolean;
+    checks: number;
+    passed: number;
+    failed: number;
+    coveredRouteMethods: number;
+    unassertedCases: number[];
+    uncovered: {
+        route: string;
+        method: string;
+    }[];
+    policies: Record<string, PolicyInventory>;
+    compliance: ComplianceReport | null;
+}
+export interface BenchmarkOptions {
+    requests?: number | undefined;
+    concurrency?: number | undefined;
+    maxP95Ms?: number | undefined;
+    seconds?: number | undefined;
+    warmup?: number | undefined;
+    target?: string | undefined;
+}
+export interface BenchmarkReport {
+    pass: boolean;
+    requested: number;
+    completed: number;
+    complete: boolean;
+    failed: number;
+    transportErrors: number;
+    shedResponses: number;
+    concurrency: number;
+    workloadCases: number;
+    exercisedWorkloadCases: number;
+    workload: string;
+    target: string | null;
+    warmupRequests: number;
+    elapsedMs: number;
+    requestsPerSecond: number;
+    p50Ms: number | null;
+    p95Ms: number | null;
+    p99Ms: number | null;
+    maxP95Ms: number | null;
+    statuses: Record<string, number>;
+    rssMiB: number | null;
+    node: string;
+    platform: string;
+}
+/** Narrows a compiled route to one that redirects, so redirectLocation can read its spec. */
+export declare const hasRedirect: (route: CompiledRoute) => route is CompiledRoute & {
+    redirect: CompiledRedirect;
+};
+export declare const probeAgent = "Mozilla/5.0 (compatible; RouteProbe/0.1)";
+export declare function projectPlan(compiled: CompiledRoutes<CompiledRoute>): ProjectPlan;
+export declare function readCases(root: string, optional?: boolean): Promise<RequestCase[]>;
+export declare function benchmarkTarget(value: string): BenchmarkTarget;
+export declare function hit(app: AuditableApp, test: RequestCase, agent: Agent, target?: BenchmarkTarget): Promise<HitResult>;
+export declare function auditProject(app: AuditableApp, { expectRoutes, log, compliance }?: AuditOptions): Promise<AuditReport>;
+export declare function benchmarkProject(app: AuditableApp, { requests, concurrency, maxP95Ms, seconds, warmup, target }?: BenchmarkOptions): Promise<BenchmarkReport>;

package/dist/types/router.d.ts

@@ -0,0 +1,11 @@
+import type { CompiledRouteTable, LoadedDocument } from './types.ts';
+export { parseTarget, matchRoute, contextFor, resolveValue, redirectLocation } from './match.ts';
+/** The grants compileRoutes consults: a validated OperatorPolicy (policy.ts) or nothing, which denies every binding. */
+export interface BindingPermissions {
+    projectSha256?: string;
+    routes?: Record<string, {
+        env?: string[];
+        secrets?: string[];
+    }>;
+}
+export declare function compileRoutes(loaded: LoadedDocument, bindings: Record<string, string | undefined>, permissions?: BindingPermissions, projectSha256?: string): Promise<CompiledRouteTable>;