@jimhoyd/urlcode 0.5.6 → 0.5.9

package/dist/readiness.js

@@ -6,14 +6,15 @@ import { join } from 'node:path';
 import { readFile, lstat } from 'node:fs/promises';
 import { safeFile } from './config.js';
 import { assert } from './errors.js';
+import { isRecord } from './object-guards.js';
 import { parseTarget, matchRoute, contextFor, redirectLocation } from './router.js';
 import { runCompliance } from './compliance.js';
-                                                                                                              
+import { handlerNames as handlers } from './types.js';
+                                                                                                                           
                                                                            
                                                                  
 
-                                             
-                                                                                                                                       
+                                                          
 /** One configured route as the inventory reports it: a PlanInventoryEntry with the handler kind named. */
                                                             
                                    
@@ -31,26 +32,26 @@ import { runCompliance } from './compliance.js';
                                                     
  
 /** Where a captured value comes from: a dotted path into a JSON response body, or one response header. */
-                                                                
+                                                         
 /** A step that closes and restarts the runtime on the same project and data directory. */
-                                              
+                                       
 /** An ordered fixture: requests that share captured values, optionally with restarts between them. */
-                                                                      
+                                                               
                                                  
 export const isStepsFixture = (fixture         )                          => 'steps' in fixture;
-export const isRestartable = (app              )                        => typeof (app                           ).restart === 'function';
+const isRestartable = (app              )                        => typeof (app                           ).restart === 'function';
 const isRestart = (step                           )                      => 'restart' in step;
                                                                                                                                  
 /** `captured` holds values from a step's `capture`; callers use it for substitution only and never print it. */
-                                                                                                                                   
+                                                                                                                            
                                                                                               
 /** A started server as the audit and benchmark see it. structural: the real type is startServer's result in src/server.ts. */
                                                                                                                                               
 /** An app that can also close and restart itself on the same project and data directory (fixture `restart` steps). */
                                                                                  
                                                                            
-                                                                                                                                        
-                              
+                                                                                                                                 
+                       
                                     
                                                                          
                                                                                                
@@ -71,17 +72,15 @@ const isRestart = (step                           )                      => 'res
                                                                                         
                                                    
  
-                                                                                                                                                                                                                            
-                                  
+                                                                                                                                                                                                                     
+                           
                                                                                                                                                               
                                                                                                                                                                        
                                                                                                                                                                                      
  
 
-const handlers = ['extension','proxy','conditional','redirect','function','page','static','download','respond']                                          ;
 /** Narrows a compiled route to one that redirects, so redirectLocation can read its spec. */
 export const hasRedirect = (route               )                                                          => Boolean(route.redirect);
-const isRecord = (value         )                                   => value !== null && typeof value === 'object' && !Array.isArray(value);
 // Probes identify themselves so an agents policy that denies an empty
 // User-Agent does not fail every generated case; fixtures may override it.
 export const probeAgent = 'Mozilla/5.0 (compatible; RouteProbe/0.1)';
@@ -193,12 +192,12 @@ export async function readFixtures(root        , optional = false)
   return cases             ; // trust boundary: fixture JSON, validated field by field above
 }
 /** Single-request fixtures only: the benchmark replays these and cannot run ordered steps. */
-export async function readCases(root        , optional = false)                         {
+async function readCases(root        , optional = false)                         {
   return (await readFixtures(root,optional)).filter((fixture)                         => !isStepsFixture(fixture));
 }
 /** One request a fixture run sent: `test` is the request as sent (captured values filled in), `original` as written. Print `original`, never `test`. */
-                                                                                                                           
-                              
+                                                                                                                    
+                       
                                                                         
                                                                                                                
                                               

package/dist/review.js

@@ -24,8 +24,8 @@ import {effectivePolicies} from './policies.js';
                                                                              
  
 
-export const reviewModuleByteLimit = MODULE_BYTE_LIMIT;
-export const reviewExcerptLimit = 240;
+const reviewModuleByteLimit = MODULE_BYTE_LIMIT;
+const reviewExcerptLimit = 240;
 
                                                  
 function locate(source        , at        )        {

package/dist/route-diff.js

@@ -2,17 +2,17 @@
 // was added, removed or changed. Pure and generic: it knows nothing about
 // pull requests; the GitHub action renders its Markdown into a PR comment.
 import { ConfigError } from './errors.js';
+import { isRecord } from './object-guards.js';
                                                                  
 
 /** One route as the diff sees it: the inventory entry plus its policy description from the `policies` map. */
-                                                                                            
+                                                                                     
 /** The parts of a `urlcode routes` report the diff reads. */
                                                                                                                                   
-                                                                                      
-                                                                                                   
+                                                                               
+                                                                                            
 
 const states                        = ['active','disabled','expired'];
-const isRecord = (value         )                                   => value !== null && typeof value === 'object' && !Array.isArray(value);
 const isStrings = (value         )                    => Array.isArray(value) && value.every(item => typeof item === 'string');
 function entry(value         , index        )                     {
   const fail = (what        )        => { throw new ConfigError(`Route report inventory[${index}] ${what}`); };

package/dist/router.js

@@ -19,7 +19,7 @@ import { parameterName } from './match.js';
 export { parseTarget, matchRoute, contextFor, resolveValue, redirectLocation } from './match.js';
 
 /** The grants compileRoutes consults: a validated OperatorPolicy (policy.ts) or nothing, which denies every binding. */
-                                                                                                                               
+                                                                                                                        
                                                
                                                     
 

package/dist/runtime.js

@@ -278,7 +278,10 @@ export async function createRuntime(project        , rawOptions
         let native                           ;
         if(route.extension){native=extensionResponse(await extensionRegistry.entries.get(route.extension) .instance.handle(extensionRequest),assetContext(method,parsed.path,route.pattern));}
         else if(route.compiledProxy){
-          try {const result=await executeProxy(proxyClient,route.compiledProxy,{method,url:origin+target,params:path,headers:Object.fromEntries(headers),...(body?{body}:{})});native={status:result.status,headers:Object.entries(result.headers),body:result.body};}
+          // Same credential-free projection a guest function receives: an
+          // extension-declared credential header in requestHeaders must not
+          // reach the upstream any more than it reaches a function's code.
+          try {const result=await executeProxy(proxyClient,route.compiledProxy,{method,url:origin+target,params:path,headers:Object.fromEntries(guestHeaders),...(body?{body}:{})});native={status:result.status,headers:Object.entries(result.headers),body:result.body};}
           catch(error){throw new HttpError(error instanceof EgressError&&error.code==='timeout'?504:error instanceof EgressError&&['busy','closed','aborted'].includes(error.code)?503:502,'Proxy upstream unavailable');}
         }
         else if (route.conditionalRoutes) {

package/dist/scaffold.js

@@ -2,6 +2,7 @@ import {realpath,lstat,readFile,mkdir,open} from 'node:fs/promises';
 import {join,extname} from 'node:path';
 import {parseYaml,validateDocument,MAX_CONFIG_BYTES} from './config.js';
 import {assert} from './errors.js';
+import {isCode} from './object-guards.js';
                                                                             
 
                                                     
@@ -11,7 +12,6 @@ import {assert} from './errors.js';
 
 const html='<!doctype html>\n<html lang="en"><meta charset="utf-8"><title>TODO</title><body><h1>TODO: replace this placeholder</h1></body></html>\n';
 const sensitive=/^(?:node_modules|package(?:-lock)?\.json|.*\.(?:pem|key|p12|pfx|env))$/i;
-const isCode=(error         ,code        )         =>error instanceof Error && 'code' in error && error.code===code;
 function parts(path        )           {
   assert(typeof path==='string' && path.length<=1024,'Invalid scaffold path');
   const values=path.split('/');

package/dist/schema-query.js

@@ -1,6 +1,7 @@
 import {readFileSync} from 'node:fs';
 import {fileURLToPath} from 'node:url';
 import {ConfigError} from './errors.js';
+import {isRecord as object} from './object-guards.js';
 
                                  
                                                                                  
@@ -10,7 +11,6 @@ function schema()      {
   cached??=JSON.parse(readFileSync(fileURLToPath(new URL('../schemas/urlcode.schema.json',import.meta.url)),'utf8'))        ;
   return cached;
 }
-const object=(value        )              =>value!==null&&typeof value==='object'&&!Array.isArray(value);
 const properties=(node     )     =>object(node.properties)?node.properties:{};
 function definition(root     ,ref       )      {
   const defs=object(root.$defs)?root.$defs:{};

package/dist/server.js

@@ -20,6 +20,28 @@ import { compileTrustedProxies, resolveClient } from './client-address.js';
                                                                                                                               
                                                                         
                                                                                                                                                             
+                                                                                      
+                                                                                      
+                                                                                   
+                                     
+                                      
+                                                                                      
+                                                                                     
+                                                                                    
+                                                                                             
+                                        
+                                                                                     
+                                                                                
+                                                                           
+                                                                                      
+                                   
+                                      
+                                                                                        
+                                        
+                                                                                                  
+                                        
+                                                                           
+                                          
                                                                                                      
                                                                                                  
                                                                                                        
@@ -105,7 +127,10 @@ async function startServerCore({ project = '.', host = '127.0.0.1', port = 3000,
   local = false, log = createJsonLogger(),
   maxBodyBytes = 1048576, maxInFlightRequests = 64, maxInFlightHealthRequests = 16,
   requestLog = 'minimal', trustRequestId = false, origin, trustedProxies = [],
-  observers = [], metrics = false, metricsIntervalMs = 0, ...runtimeOptions }                = {})                  {
+  observers = [], metrics = false, metricsIntervalMs = 0, healthDetails = metrics,
+  readinessDrainMs = 0, closeTimeoutMs = 10000,
+  headersTimeoutMs = 10000, requestTimeoutMs = 15000, keepAliveTimeoutMs = 5000,
+  ...runtimeOptions }                = {})                  {
   // Which peers may set X-Forwarded-For. Empty means the socket peer is the
   // client for every policy; a forwarded header from anyone else is ignored.
   const proxies = compileTrustedProxies(trustedProxies);
@@ -116,6 +141,12 @@ async function startServerCore({ project = '.', host = '127.0.0.1', port = 3000,
   assert(typeof trustRequestId === 'boolean', 'Request ID trust must be a boolean');
   assert(typeof metrics === 'boolean', 'Metrics exposition must be a boolean');
   assert(metricsIntervalMs === 0 || (Number.isInteger(metricsIntervalMs) && metricsIntervalMs >= 1000 && metricsIntervalMs <= 3600000), 'Metrics interval must be 0 or 1000–3600000 ms');
+  assert(typeof healthDetails === 'boolean', 'Health details exposition must be a boolean');
+  assert(Number.isInteger(readinessDrainMs) && readinessDrainMs >= 0 && readinessDrainMs <= 300000, 'Readiness drain delay must be 0–300000 ms');
+  assert(Number.isInteger(closeTimeoutMs) && closeTimeoutMs >= 0 && closeTimeoutMs <= 300000, 'Close timeout must be 0–300000 ms');
+  assert(Number.isInteger(headersTimeoutMs) && headersTimeoutMs >= 1000 && headersTimeoutMs <= 300000, 'Headers timeout must be 1000–300000 ms');
+  assert(Number.isInteger(requestTimeoutMs) && requestTimeoutMs >= 1000 && requestTimeoutMs <= 300000, 'Request timeout must be 1000–300000 ms');
+  assert(Number.isInteger(keepAliveTimeoutMs) && keepAliveTimeoutMs >= 0 && keepAliveTimeoutMs <= 300000, 'Keep-alive timeout must be 0–300000 ms');
   if (origin) {
     let u     ;
     try { u = new URL(origin); } catch { assert(false, 'Invalid public origin'); }
@@ -127,9 +158,11 @@ async function startServerCore({ project = '.', host = '127.0.0.1', port = 3000,
   const counters = sink.metrics;
   const emit = (event                         , context                )       => { try { sink(event, context); } catch { /* Logging cannot fail requests. */ } };
   let current          = await createRuntime(project, { local, log: emit, origin, ...runtimeOptions });
-  let shuttingDown = false, reloading = false, watching = false, interval                            , lastFingerprint                    , inFlight = 0, healthInFlight = 0;
+  // `draining` flips /_urlcode/ready unhealthy ahead of `shuttingDown`, which stops
+  // serving entirely; the gap between them is the pre-close readiness delay.
+  let shuttingDown = false, draining = false, reloading = false, watching = false, interval                            , lastFingerprint                    , inFlight = 0, healthInFlight = 0;
   const retired = new Set               ();
-  const server = http.createServer({ maxHeaderSize: 16384, headersTimeout: 10000, requestTimeout: 15000, keepAliveTimeout: 5000 }, async (req, res) => {
+  const server = http.createServer({ maxHeaderSize: 16384, headersTimeout: headersTimeoutMs, requestTimeout: requestTimeoutMs, keepAliveTimeout: keepAliveTimeoutMs }, async (req, res) => {
     const started = performance.now();
     const url = req.url ?? '', method = req.method ?? 'GET';
     // Upstream correlation is opt-in: an untrusted client must not choose the ID
@@ -162,8 +195,13 @@ async function startServerCore({ project = '.', host = '127.0.0.1', port = 3000,
         if (!['GET','HEAD'].includes(method)) result = { status: 405, headers: [['allow','GET, HEAD']], body: Buffer.alloc(0) };
         else if (url === '/_urlcode/metrics') result = { status: 200, headers: [['content-type','text/plain; version=0.0.4; charset=utf-8'],['cache-control','no-store']], body: Buffer.from(renderPrometheus(snapshot())) };
         else {
-          const ready = url === '/_urlcode/health' || current.healthy;
-          result = { status: ready ? 200 : 503, headers: [['content-type','application/json']], body: Buffer.from(JSON.stringify({ status: ready ? 'ok' : 'degraded', version: current.version, routes: current.count })) };
+          // Liveness (/_urlcode/health) stays healthy while draining, so a supervisor does
+          // not restart a process that is deliberately finishing in-flight work; readiness
+          // (/_urlcode/ready) reflects the drain so a load balancer stops routing here.
+          const ready = url === '/_urlcode/health' ? true : (!draining && current.healthy);
+          const body                          = { status: ready ? 'ok' : 'degraded' };
+          if (healthDetails) { body.version = current.version; body.routes = current.count; }
+          result = { status: ready ? 200 : 503, headers: [['content-type','application/json']], body: Buffer.from(JSON.stringify(body)) };
         }
         req.resume();
       } else {
@@ -202,7 +240,7 @@ async function startServerCore({ project = '.', host = '127.0.0.1', port = 3000,
   const snapshot = ()                  => { const { healthy, slots } = current.workers; const out = counters.snapshot(); out.functionWorkers.healthySlots = healthy; out.functionWorkers.slots = slots; return out; };
   let metricsTimer                            ;
   if (metricsIntervalMs) { metricsTimer = setInterval(() => sink.publish(snapshot()), metricsIntervalMs); metricsTimer.unref(); }
-  server.setTimeout(15000, socket => socket.destroy());
+  server.setTimeout(requestTimeoutMs, socket => socket.destroy());
   server.maxRequestsPerSocket = 1000;
   server.maxConnections = 1024;
   server.on('clientError', (error, socket) => {
@@ -252,8 +290,12 @@ async function startServerCore({ project = '.', host = '127.0.0.1', port = 3000,
     // the operator's --origin, never a forwarded header.
     origin: publicOrigin(),
     async close() {
+      if (!draining) {
+        draining = true;
+        if (readinessDrainMs > 0) await new Promise      (resolve => setTimeout(resolve, readinessDrainMs));
+      }
       shuttingDown = true; clearInterval(interval); clearInterval(metricsTimer);
-      const deadline = setTimeout(() => server.closeAllConnections(), 10000);
+      const deadline = setTimeout(() => server.closeAllConnections(), closeTimeoutMs);
       deadline.unref();
       await new Promise      (resolve => server.close(() => resolve()));
       clearTimeout(deadline);

package/dist/signals.js

@@ -1,8 +1,8 @@
 import { egressUrl, safeEgressHeaders } from './egress.js';
                                                   
                                                                                 
-                                                                           
-                                                                                                 
+                                                                    
+                                                                                          
 export function validateSignal(definition                 )      {if(!definition||typeof definition!=='object'||Object.keys(definition).some(key=>!['url','headers'].includes(key))) throw new Error('Invalid signal');egressUrl(definition.url);safeEgressHeaders(definition.headers||{});}
 /** No queue, retries, ordering promise, or durable delivery. Counters contain no URL/header data. */
 export class SignalBroker {

package/dist/site.js

@@ -6,7 +6,7 @@ import { publishableAssetName } from './assets.js';
 import { lists as bundled } from '../data/agents/index.js';
                                                                                                                                                   
 
-                                                                                                               
+                                                                                                        
                                                                 
                                 
 
@@ -239,7 +239,7 @@ export async function applySite(loaded                , options              = {
 // bounded and static: no templating, no request data. It is text/html; the
 // artifact is JSON, which does the escaping, and a body that is not valid
 // UTF-8 is refused rather than silently altered.
-export const notFoundInlineLimit = 65536;
+const notFoundInlineLimit = 65536;
 export async function inlineNotFound(loaded                )                   {
   const site = loaded.document.site, path = generatedPaths.notFound;
   const route = loaded.routes[path];

package/dist/trusted-functions.js

@@ -34,7 +34,7 @@ import { routeFunctions } from './function-sources.js';
                                                           
                                                                     
 
-                                                                                                          
+                                                                                                   
                                                               
                                                             
                                                                                                    

package/dist/types/assets.d.ts

@@ -1,13 +1,14 @@
 import type { AssetResult, CompiledRoute } from './types.ts';
 /** The header surface assetResponse reads for conditional and range requests. */
-export interface AssetRequestHeaders {
+interface AssetRequestHeaders {
     has(name: string): boolean;
     get(name: string): string | null | undefined;
 }
-export interface AssetSnapshot {
+interface AssetSnapshot {
     watch: string[];
     digest: string;
 }
 export declare const publishableAssetName: (name: string) => boolean;
 export declare function compileAssets(root: string, routes: CompiledRoute[]): Promise<AssetSnapshot>;
 export declare function assetResponse(route: CompiledRoute, path: string, method: string, request: AssetRequestHeaders): AssetResult;
+export {};

package/dist/types/authoring.d.ts

@@ -1,14 +1,11 @@
 import type { DependencySet } from './project-dependencies.ts';
-export interface InitOptions {
+interface InitOptions {
     /**
      * When given, a `package.json` pinning exactly these versions is written beside `urlcode.yaml`. Route-only
      * initialization stays the default: a project whose runtime is managed elsewhere gets no manifest at all.
      */
     manifest?: DependencySet | undefined;
-    /** `default` (function, middleware, redirect) or `page`: urlcode.yaml, public/index.html, a README and fixtures only. */
-    template?: 'default' | 'page' | 'redirects' | undefined;
 }
-/** Adds what the starter needs to an existing package.json and changes nothing else; a conflicting script is refused, never overwritten. */
-export declare function mergePackageJson(text: string, scripts: Record<string, string>, dependency: string, version: string): string;
-export declare function initProject(destination: string, { manifest, template }?: InitOptions): Promise<string>;
+export declare function initProject(destination: string, { manifest }?: InitOptions): Promise<string>;
 export declare function addRedirect(project: string, destination: string, alias?: string | undefined): Promise<string>;
+export {};

package/dist/types/body-schema.d.ts

@@ -29,7 +29,7 @@ export declare function assertBodySchema(schema: unknown): asserts schema is Bod
  * is the schema keyword that failed, and `expected` is the schema's own
  * constraint. Nothing the client sent is ever placed in an issue.
  */
-export interface BodySchemaIssue {
+interface BodySchemaIssue {
     pointer: string;
     keyword: string;
     message: string;
@@ -56,3 +56,4 @@ export declare const bodySchemaLine: (issue: BodySchemaIssue) => string;
 export declare function prefersJson(accept: string | null | undefined): boolean;
 /** Renders the JSON answer: never more than `maxIssueBytes`, dropping trailing issues and saying so. */
 export declare function bodySchemaJson(issues: BodySchemaIssue[]): string;
+export {};

package/dist/types/catalog.d.ts

@@ -36,7 +36,7 @@ export interface CatalogMetadata {
     behavior?: string[];
 }
 /** The fields the capability preflight determines; `npm run check` refuses hand-written values that differ. */
-export interface DerivedMetadata {
+interface DerivedMetadata {
     capabilities: CapabilityName[];
     targets: Record<CapabilityTarget, TargetVerdict>;
     routes: number;
@@ -59,3 +59,4 @@ export declare function searchTerms(text: string): string[];
  * Ties keep catalog order, so the smallest entry wins when a caller sorts by size first.
  */
 export declare function searchMetadata<T extends CatalogMetadata>(entries: readonly T[], text: string, extraText?: (entry: T) => string[]): SearchHit<T>[];
+export {};

package/dist/types/config.d.ts

@@ -1,4 +1,3 @@
-import type { ErrorObject } from 'ajv';
 import type { LoadedDocument, ProjectDocument, RouteConfig, SharedBlock } from './types.ts';
 /** What config-worker.ts posts back: the loaded document, or the ConfigError message. */
 export type ConfigWorkerResult = {
@@ -11,13 +10,6 @@ export interface ConfigWorkerData {
 }
 export declare const MAX_CONFIG_BYTES: number;
 export declare function parseYaml(text: string): unknown;
-/**
- * One line for the first schema violation. Closed-key-set failures name the offending key and the keys the
- * schema allows, and required failures name the missing key, because a bare keyword sends the reader hunting.
- * Only key names, which come from the schema or the author's own mapping keys, are echoed, never values
- * (values may hold secrets), and never more than MAX_NAMED_KEY characters of a key.
- */
-export declare function describeSchemaError(e: ErrorObject): string;
 export declare function validateDocument(data: unknown, inherited?: Record<string, SharedBlock>): ProjectDocument;
 /** The input declaration a short-form function gets for each `{param}` it does not declare itself. */
 export declare const SHORT_FORM_PATH_SCHEMA: {

package/dist/types/context.d.ts

@@ -15,6 +15,7 @@ export interface ProjectContext {
     project: {
         entry: string;
         routes: number;
+        routeCountNote: string;
         handlers: Record<string, number>;
         extensions: string[];
         policies: {
@@ -80,7 +81,7 @@ export interface TaskShape {
 /** Established by running `urlcode validate` and `urlcode test` on each shape; test/context.test.ts compiles every `yaml` entry so this cannot drift from the runtime. */
 export declare const redirectShapes: TaskShape[];
 /** A complete, paste-ready project skeleton: every supported shape merged into one urlcode.yaml, plus the start script. */
-export interface TaskStarter {
+interface TaskStarter {
     file: string;
     yaml: string;
     /** Files the yaml references that must exist, with minimal content. */
@@ -120,3 +121,4 @@ export declare function buildTaskContext(project: string, task: string, options?
     hostFile?: string | undefined;
     projectFlag?: string | undefined;
 }): Promise<TaskContext>;
+export {};

package/dist/types/egress.d.ts

@@ -12,7 +12,7 @@ export interface EgressResponse {
     headers: Record<string, string>;
     body: Buffer;
 }
-export interface EgressOptions {
+interface EgressOptions {
     grantOrigins: string[];
     timeoutMs?: number;
     maxRequestBytes?: number;

package/dist/types/explain.d.ts

@@ -1,14 +1,13 @@
 import type { CapabilityName, CapabilityTarget } from './capabilities.ts';
 import type { RuntimeExtension } from './extensions.ts';
-import type { CompiledRoute, LoadedDocument, PolicyChain, PolicyInventory, RouteState } from './types.ts';
-import type { HandlerName } from './readiness.ts';
+import type { CompiledRoute, HandlerName, LoadedDocument, PolicyChain, PolicyInventory, RouteState } from './types.ts';
 import type { ParameterSchema, ParameterLocation } from './match.ts';
 import type { RequestBodyPolicy } from './http-policy.ts';
 export interface ExplainedHandler {
     kind: HandlerName | 'none';
     [detail: string]: unknown;
 }
-export interface ExplainedParameter {
+interface ExplainedParameter {
     name: string;
     in: ParameterLocation;
     required: boolean;
@@ -93,7 +92,7 @@ export interface RouteExplanation {
     targets: Record<CapabilityTarget, TargetSupport>;
     note: string;
 }
-export interface ExplainOptions {
+interface ExplainOptions {
     extensions?: RuntimeExtension[] | undefined;
     projectSha256?: string | undefined;
     now?: number | undefined;
@@ -101,3 +100,4 @@ export interface ExplainOptions {
 /** Describe one compiled route. `chain` is the policy chain compiled for it, when the project declares policies. */
 export declare function explainCompiledRoute(loaded: LoadedDocument, route: CompiledRoute, chain: PolicyChain | undefined, options?: ExplainOptions): RouteExplanation;
 export declare function nearestRoutes(target: string, patterns: Iterable<string>, limit?: number): string[];
+export {};

package/dist/types/extension-artifacts.d.ts

@@ -1,8 +1,6 @@
 import { type ReleaseAsset } from './extension-transport.ts';
-/** Offline, declarative extension bundles. These are deliberately not Node packages. */
-export declare const ARTIFACT_REPOSITORY = "jimhoyd-com/urlcode";
 export declare const ARTIFACT_WORKFLOW = "jimhoyd-com/urlcode/.github/workflows/extension-artifacts.yml";
-export interface ArtifactEntry {
+interface ArtifactEntry {
     name: string;
     version: string;
     asset: string;
@@ -19,13 +17,13 @@ export interface Catalog {
         reason: string;
     }[];
 }
-export interface LockedArtifact extends ArtifactEntry {
+interface LockedArtifact extends ArtifactEntry {
     catalog: {
         tag: string;
         commit: string;
     };
 }
-export interface ExtensionLock {
+interface ExtensionLock {
     format: 1;
     artifacts: LockedArtifact[];
 }
@@ -35,7 +33,7 @@ export interface TarFile {
     path: string;
     bytes: Uint8Array;
 }
-export interface ArchiveLimits {
+interface ArchiveLimits {
     archive: number;
     expanded: number;
     files: number;
@@ -45,7 +43,6 @@ export interface ArchiveLimits {
 /** A minimal tar reader: only regular files are accepted, before any write occurs. */
 export declare function readBoundedTgz(source: Uint8Array, limits: ArchiveLimits): TarFile[];
 export declare function extractArtifact(bytes: Uint8Array, entry: ArtifactEntry, destination: string): Promise<void>;
-export declare function readLock(project: string): Promise<ExtensionLock>;
 export declare function writeLock(project: string, lock: ExtensionLock): Promise<void>;
 export declare function cachePath(project: string, sha256: string): string;
 export type { ReleaseAsset };
@@ -54,12 +51,6 @@ export interface ArtifactTransport {
     download(url: string): Promise<Uint8Array>;
     attest(path: string, release: string): Promise<void>;
 }
-/** The default transport accepts only GitHub Release asset URLs and verifies every downloaded subject. */
-export declare const githubTransport: ArtifactTransport;
-export declare function resolveCatalog(release: string, transport?: ArtifactTransport): Promise<{
-    catalog: Catalog;
-    assets: ReleaseAsset[];
-}>;
 export declare function installArtifact(project: string, release: string, artifactName: string, transport?: ArtifactTransport): Promise<ExtensionLock>;
 export declare function inspectArtifacts(project: string): Promise<{
     lock: ExtensionLock;

package/dist/types/extension-transport.d.ts

@@ -1,6 +1,8 @@
+import { isRecord } from './object-guards.ts';
+import type { UnknownRecord } from './object-guards.ts';
 /** Shared GitHub release/cache/lockfile plumbing for extension-artifacts.ts and extension-bundles.ts. No opinion on what content is allowed or executable; that trust boundary stays local to each caller (#441). */
-export type UnknownRecord = Record<string, unknown>;
-export declare const isRecord: (v: unknown) => v is UnknownRecord;
+export { isRecord };
+export type { UnknownRecord };
 export declare const digestHex: (bytes: Uint8Array) => string;
 export declare function textField(value: unknown, what: string): string;
 export declare function exactKeys(value: UnknownRecord, expected: readonly string[], what: string): void;
@@ -12,12 +14,12 @@ export interface ReleaseAsset {
     name: string;
     url: string;
 }
-export interface GithubTransport {
+interface GithubTransport {
     release(tag: string): Promise<ReleaseAsset[]>;
     download(url: string): Promise<Uint8Array>;
     attest(path: string, release: string): Promise<void>;
 }
-export interface GithubTransportConfig {
+interface GithubTransportConfig {
     repository: string;
     workflow: string;
     tagPattern: RegExp;

package/dist/types/functions.d.ts

@@ -30,7 +30,7 @@ export interface SandboxPoolOptions {
     maxBytes?: number | undefined;
     log?: LogFn | undefined;
 }
-export type FunctionPoolOptions = SandboxPoolOptions;
+type FunctionPoolOptions = SandboxPoolOptions;
 export interface FunctionWorkerData {
     sources: Record<string, string>;
     dependencies: Record<string, string[]>;

package/dist/types/http-response.d.ts

@@ -7,18 +7,18 @@ export interface HandlerResult {
     body?: ResponseBody;
     contentLength?: number;
 }
-export interface PreparedResponse {
+interface PreparedResponse {
     status: number;
     headers: HeaderPair[];
     cookies: string[];
     body: ResponseBody;
 }
-export interface ErrorAnswer {
+interface ErrorAnswer {
     status: number;
     headers: HeaderPair[];
     body: string | undefined;
 }
-export interface ResponseOptions {
+interface ResponseOptions {
     requestId: string;
     method: string;
 }
@@ -31,8 +31,11 @@ export interface ResponseWriter {
     removeHeader(name: string): void;
     end(body?: ResponseBody): unknown;
     destroy(): unknown;
+    strictContentLength?: boolean;
 }
 export declare function prepareResponse(result: HandlerResult, { requestId, method }: ResponseOptions): PreparedResponse;
+/** The UTF-8 bytes a body occupies on the wire; a string's `.length` counts UTF-16 units, not bytes. */
+export declare function byteLength(body: ResponseBody): number;
 export declare function writeResponse(res: ResponseWriter, result: HandlerResult, options: ResponseOptions): number;
 export declare function errorResponse(error: unknown, { requestId, method, headers }: ResponseOptions & {
     headers?: HeaderPair[];
@@ -40,3 +43,4 @@ export declare function errorResponse(error: unknown, { requestId, method, heade
 export declare function writeError(res: ResponseWriter, error: unknown, options: ResponseOptions & {
     headers?: HeaderPair[];
 }): number;
+export {};