@astrale-os/kernel-protocol 0.5.0-beta.10

package/dist/publication/schema.js

@@ -0,0 +1,15 @@
+import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
+import { admitBundleDescriptor } from './bundle-descriptor.js';
+import { exact, record } from './content.js';
+import { fail } from './error.js';
+export function admitSchema(input) {
+    const value = record(input, 'PUBLICATION_INVALID', 'Published schema is invalid.');
+    exact(value, ['revision', 'bundle'], 'PUBLICATION_INVALID');
+    if (typeof value.revision !== 'string' || !patterns.revision.test(value.revision)) {
+        fail('PUBLICATION_INVALID', 'Published schema revision is invalid.');
+    }
+    return Object.freeze({
+        revision: value.revision,
+        bundle: admitBundleDescriptor(value.bundle),
+    });
+}

package/dist/routes/admission.d.ts

@@ -0,0 +1,3 @@
+import type { Table } from './table.js';
+/** Admit one emitted portable Table before Server composition. */
+export declare function acceptTable(input: unknown): Table;

package/dist/routes/admission.js

@@ -0,0 +1,89 @@
+import { accept as acceptPortable } from '@astrale-os/kernel-dsl/value';
+import { acceptReference } from '../publication/reference.js';
+import { admitRoute } from '../publication/route.js';
+import { fail } from './error.js';
+const AUTH = new Set(['anonymous', 'authenticated', 'authorized']);
+const OUTPUT = new Set(['value', 'stream', 'binary']);
+/** Admit one emitted portable Table before Server composition. */
+export function acceptTable(input) {
+    const value = object(acceptPortable(input), 'Route Table');
+    exact(value, ['publication', 'entries'], 'Route Table');
+    const reference = acceptReference(value.publication);
+    if (!Array.isArray(value.entries))
+        invalid('Route Table entries');
+    const entries = value.entries.map((entry) => acceptRoute(entry, reference.origin));
+    if (new Set(entries.map(({ name }) => name)).size !== entries.length) {
+        fail('NATIVE_ROUTE_BINDING_INVALID', 'Route Table names must be unique.');
+    }
+    return Object.freeze({ publication: reference, entries: Object.freeze(entries) });
+}
+function acceptRoute(input, origin) {
+    const value = object(input, 'Route Table entry');
+    exact(value, ['name', 'callable', 'target', 'auth', 'output', 'href', 'method', 'default'], 'Route Table entry', ['requestMethod', 'query', 'headers', 'body', 'credential']);
+    if (typeof value.default !== 'boolean')
+        invalid('Route Table default');
+    if (typeof value.auth !== 'string' || !AUTH.has(value.auth)) {
+        invalid('Route Table auth');
+    }
+    if (typeof value.output !== 'string' || !OUTPUT.has(value.output))
+        invalid('Route Table output');
+    const wire = admitRoute({
+        name: value.name,
+        callable: value.callable,
+        href: value.href,
+        method: value.method,
+        ...(value.default === true ? { default: true } : {}),
+        ...(value.requestMethod === undefined ? {} : { requestMethod: value.requestMethod }),
+        ...(value.query === undefined ? {} : { query: value.query }),
+        ...(value.headers === undefined ? {} : { headers: value.headers }),
+        ...(value.body === undefined ? {} : { body: value.body }),
+        ...(value.credential === undefined ? {} : { credential: value.credential }),
+        ...receiver(value.target),
+    }, origin);
+    const { default: _default, receiver: _receiver, ...common } = wire;
+    return Object.freeze({
+        ...common,
+        target: target(value.target),
+        auth: value.auth,
+        output: value.output,
+        default: value.default,
+    });
+}
+function target(input) {
+    const value = object(input, 'Route target');
+    if (value.kind === 'function') {
+        exact(value, ['kind'], 'Route Function target');
+        return Object.freeze({ kind: 'function' });
+    }
+    if (value.kind !== 'method' || (value.dispatch !== 'static' && value.dispatch !== 'instance')) {
+        invalid('Route Method target');
+    }
+    if (value.dispatch === 'static') {
+        exact(value, ['kind', 'dispatch'], 'Route static Method target');
+        return Object.freeze({ kind: 'method', dispatch: 'static' });
+    }
+    exact(value, ['kind', 'dispatch', 'receiver'], 'Route instance Method target');
+    if (typeof value.receiver !== 'string')
+        invalid('Route receiver');
+    return Object.freeze({ kind: 'method', dispatch: 'instance', receiver: value.receiver });
+}
+function receiver(input) {
+    const admitted = target(input);
+    return admitted.kind === 'method' && admitted.dispatch === 'instance'
+        ? { receiver: admitted.receiver }
+        : {};
+}
+function object(input, label) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        invalid(label);
+    return input;
+}
+function exact(value, required, label, optional = []) {
+    const allowed = new Set([...required, ...optional]);
+    if (Object.keys(value).some((key) => !allowed.has(key)) ||
+        required.some((key) => !Object.hasOwn(value, key)))
+        invalid(label);
+}
+function invalid(label) {
+    return fail('NATIVE_ROUTE_BINDING_INVALID', `${label} is invalid.`);
+}

package/dist/routes/binding.d.ts

@@ -0,0 +1,6 @@
+import type { Domain } from '@astrale-os/kernel-dsl/v1';
+import type { Publication } from '../publication/publication.js';
+import type { Plan } from './plan.js';
+import type { Table } from './table.js';
+/** Bind one Plan to an exact placed Publication and matching resolved Domain. */
+export declare function bind(plan: Plan, deployed: Publication, domain: Domain): Table;

package/dist/routes/binding.js

@@ -0,0 +1,27 @@
+import { json } from '@astrale-os/kernel-dsl/value';
+import { reference } from '../publication/reference.js';
+import { fail } from './error.js';
+import { place } from './placement.js';
+import { rejectReserved } from './reservation.js';
+/** Bind one Plan to an exact placed Publication and matching resolved Domain. */
+export function bind(plan, deployed, domain) {
+    if (plan.origin !== deployed.origin ||
+        plan.origin !== domain.origin ||
+        plan.revision !== deployed.schema.revision ||
+        plan.revision !== domain.revision) {
+        fail('NATIVE_ROUTE_BINDING_INVALID', 'Route Plan, Publication, and Domain identity differ.');
+    }
+    if (json.serialize(place(plan, deployed.identity.issuer)) !==
+        json.serialize(deployed.routes)) {
+        fail('NATIVE_ROUTE_BINDING_INVALID', 'Publication routes differ from the placed Route Plan.');
+    }
+    const entries = plan.entries.map((entry, index) => {
+        const { path: _path, ...portable } = entry;
+        return Object.freeze({ ...portable, href: deployed.routes[index].href });
+    });
+    rejectReserved(deployed, entries);
+    return Object.freeze({
+        publication: reference(deployed),
+        entries: Object.freeze(entries),
+    });
+}

package/dist/routes/collision.d.ts

@@ -0,0 +1,2 @@
+import type { Route } from './table.js';
+export declare function rejectCollisions(entries: readonly Route[]): void;

package/dist/routes/collision.js

@@ -0,0 +1,16 @@
+import { fail } from './error.js';
+import { templatesOverlap } from './template.js';
+export function rejectCollisions(entries) {
+    const accepted = [];
+    for (const entry of entries) {
+        for (const previous of accepted) {
+            if (overlap(entry.method, previous.method) && templatesOverlap(entry.href, previous.href)) {
+                fail('NATIVE_ROUTE_COLLISION', `Route ${entry.name} collides with ${previous.name}.`);
+            }
+        }
+        accepted.push(entry);
+    }
+}
+function overlap(left, right) {
+    return left === '*' || right === '*' || left === right;
+}

package/dist/routes/compiler.d.ts

@@ -0,0 +1,8 @@
+import type { Domain } from '@astrale-os/kernel-dsl/v1';
+import type * as publication from '../publication/index.js';
+import type { Plan } from './plan.js';
+export interface CompileInput {
+    readonly routes: readonly publication.HttpRouteDeclaration[];
+    readonly domain: Domain;
+}
+export declare function compile(input: CompileInput): Plan;

package/dist/routes/compiler.js

@@ -0,0 +1,50 @@
+import { admitRouteDeclaration } from '../publication/route.js';
+import { rejectCollisions } from './collision.js';
+import { fail } from './error.js';
+import { validateCredentialMapping, validateMapping, validateWireMapping } from './mapping.js';
+import { placePath } from './placement.js';
+import { validateTemplate } from './template.js';
+export function compile(input) {
+    if (input === null || typeof input !== 'object' || !Array.isArray(input.routes)) {
+        throw new TypeError('Route compilation input is invalid.');
+    }
+    const authored = input.routes.map((entry) => admitRouteDeclaration(entry, input.domain.origin));
+    const entries = authored.map((declaration) => {
+        const meaning = input.domain.callable(declaration.callable);
+        if (meaning === undefined) {
+            fail('NATIVE_ROUTE_BINDING_INVALID', `Unknown callable ${declaration.callable}.`);
+        }
+        const href = placePath(declaration.path, 'https://routes.invalid');
+        const route = { ...declaration, href };
+        validateTemplate(href);
+        validateMapping(route, meaning.inputFields, isMethod(meaning) && !meaning.static);
+        validateWireMapping(route);
+        validateCredentialMapping(route);
+        if (route.method === 'GET' && route.body !== undefined) {
+            fail('NATIVE_ROUTE_DECLARATION_INVALID', `GET route ${route.name} cannot declare a body.`);
+        }
+        const target = !isMethod(meaning)
+            ? { kind: 'function' }
+            : meaning.static
+                ? { kind: 'method', dispatch: 'static' }
+                : { kind: 'method', dispatch: 'instance', receiver: route.receiver };
+        const { href: _href, receiver: _receiver, ...portable } = route;
+        return Object.freeze({
+            ...portable,
+            target,
+            auth: meaning.auth,
+            output: meaning.output.mode,
+            path: declaration.path,
+            default: declaration.default === true,
+        });
+    });
+    rejectCollisions(entries.map((entry) => ({ ...entry, href: placePath(entry.path, 'https://routes.invalid') })));
+    return Object.freeze({
+        origin: input.domain.origin,
+        revision: input.domain.revision,
+        entries: Object.freeze(entries),
+    });
+}
+function isMethod(meaning) {
+    return 'owner' in meaning;
+}

package/dist/routes/credential.d.ts

@@ -0,0 +1,8 @@
+import type { HttpRoute, SingleCredentialSource } from '../publication/index.js';
+import type { Route } from './table.js';
+export declare function credentialSources(route: Pick<HttpRoute, 'credential'>): readonly SingleCredentialSource[];
+export declare function firstCredentialIsAmbient(entry: Route): boolean;
+export declare function specificHeaderWires(entry: Route): ReadonlySet<string>;
+export declare function putCredential(entry: Route, url: URL, headers: Record<string, string>, credential: string): void;
+export declare function withoutCredentialHeaders(entry: Route, input: Readonly<Record<string, string>>): Record<string, string>;
+export declare function readCredential(entry: Route, url: URL, headers: Record<string, string>): string | undefined;

package/dist/routes/credential.js

@@ -0,0 +1,118 @@
+import { invalidRequest } from './error.js';
+export function credentialSources(route) {
+    const source = route.credential ?? { in: 'header' };
+    return Array.isArray(source) ? source : [source];
+}
+export function firstCredentialIsAmbient(entry) {
+    return credentialSources(entry)[0].in === 'cookie';
+}
+export function specificHeaderWires(entry) {
+    return new Set(Object.values(entry.headers ?? {})
+        .filter((wire) => wire !== '*')
+        .map((wire) => wire.toLowerCase()));
+}
+export function putCredential(entry, url, headers, credential) {
+    if (entry.credential === undefined) {
+        headers.authorization = `Bearer ${credential}`;
+        return;
+    }
+    const source = credentialSources(entry)[0];
+    if (source.in === 'header') {
+        headers[(source.name ?? 'authorization').toLowerCase()] = credential;
+    }
+    else if (source.in === 'query') {
+        url.searchParams.set(source.name, credential);
+    }
+    else {
+        invalidRequest('A cookie credential is ambient and cannot be emitted by JavaScript.');
+    }
+}
+export function withoutCredentialHeaders(entry, input) {
+    const output = {};
+    for (const [name, value] of Object.entries(input)) {
+        const canonical = name.toLowerCase();
+        if (Object.hasOwn(output, canonical)) {
+            invalidRequest(`Header ${canonical} occurs more than once.`);
+        }
+        output[canonical] = value;
+    }
+    for (const source of credentialSources(entry)) {
+        if (source.in === 'header') {
+            delete output[(source.name ?? 'authorization').toLowerCase()];
+            continue;
+        }
+        if (source.in === 'cookie' && output.cookie !== undefined) {
+            const retained = withoutCookie(output.cookie, source.name);
+            if (retained === undefined)
+                delete output.cookie;
+            else
+                output.cookie = retained;
+        }
+    }
+    return output;
+}
+export function readCredential(entry, url, headers) {
+    const found = [];
+    if (entry.credential === undefined) {
+        const authorization = headers.authorization;
+        if (authorization === undefined)
+            return undefined;
+        const matched = /^Bearer[ \t]+([^\s]+)$/iu.exec(authorization.trim());
+        if (matched === null)
+            invalidRequest('Authorization must contain one Bearer credential.');
+        return matched[1];
+    }
+    for (const source of credentialSources(entry)) {
+        let value;
+        if (source.in === 'header') {
+            value = headers[(source.name ?? 'authorization').toLowerCase()];
+        }
+        else if (source.in === 'query') {
+            const values = url.searchParams.getAll(source.name);
+            if (values.length > 1) {
+                invalidRequest(`Credential query ${source.name} occurs more than once.`);
+            }
+            value = values[0];
+        }
+        else {
+            value = cookie(headers.cookie, source.name);
+        }
+        if (value !== undefined)
+            found.push(value);
+    }
+    if (found.length > 1)
+        invalidRequest('Request supplies more than one Astrale credential channel.');
+    return found[0];
+}
+function cookie(header, name) {
+    if (header === undefined)
+        return undefined;
+    const values = [];
+    for (const item of header.split(';')) {
+        const split = item.indexOf('=');
+        if (item.slice(0, split).trim() === name) {
+            try {
+                values.push(decodeURIComponent(item.slice(split + 1).trim()));
+            }
+            catch (cause) {
+                if (cause instanceof URIError)
+                    invalidRequest('Credential cookie is invalid.');
+                throw cause;
+            }
+        }
+    }
+    if (values.length > 1)
+        invalidRequest(`Credential cookie ${name} occurs more than once.`);
+    return values[0];
+}
+function withoutCookie(header, name) {
+    const retained = header.split(';').filter((item) => {
+        const split = item.indexOf('=');
+        return split < 0 || item.slice(0, split).trim() !== name;
+    });
+    const value = retained
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0)
+        .join('; ');
+    return value.length === 0 ? undefined : value;
+}

package/dist/routes/decode.d.ts

@@ -0,0 +1,5 @@
+import type { Domain } from '@astrale-os/kernel-dsl/v1';
+import type { PublicationRef } from '../publication/index.js';
+import type { HttpRequest, Invocation } from './request.js';
+import type { Route } from './table.js';
+export declare function decode(entry: Route, request: HttpRequest, domain: Domain, served: PublicationRef): Invocation;

package/dist/routes/decode.js

@@ -0,0 +1,147 @@
+import { NodePath, Path } from '@astrale-os/kernel-core/path';
+import { callableAddress } from '@astrale-os/kernel-dsl/v1/addressing';
+import * as portable from '@astrale-os/kernel-dsl/value';
+import { readCredential, specificHeaderWires, withoutCredentialHeaders } from './credential.js';
+import { fail, invalidRequest } from './error.js';
+import { isReservedHeader } from './mapping.js';
+import { methodMatches } from './match.js';
+import { bodyText, normalizeHeaders, parseJsonObject } from './request.js';
+import { decodeRouting } from './routing.js';
+import { decodeScalar } from './scalar.js';
+import { requiresReceiver } from './target.js';
+import { matchTemplate, PLACEHOLDER } from './template.js';
+export function decode(entry, request, domain, served) {
+    if (!methodMatches(entry, request.method))
+        invalidRequest('HTTP method does not match the route.');
+    const matched = matchTemplate(entry.href, request.url);
+    if (matched === undefined)
+        invalidRequest('URL does not match the route template.');
+    const values = {};
+    for (const [name, value] of Object.entries(matched)) {
+        values[name] = decodeScalar(entry, name, value, domain);
+    }
+    if (entry.requestMethod !== undefined) {
+        values[entry.requestMethod] = decodeScalar(entry, entry.requestMethod, request.method.toUpperCase(), domain);
+    }
+    let url;
+    try {
+        url = new URL(request.url);
+    }
+    catch (cause) {
+        if (cause instanceof TypeError) {
+            return fail('NATIVE_ROUTE_REQUEST_INVALID', 'Native route URL is invalid.', cause);
+        }
+        throw cause;
+    }
+    const headers = normalizeHeaders(request.headers);
+    const credential = readCredential(entry, url, headers);
+    const routing = decodeRouting(request, served);
+    const applicationHeaders = withoutCredentialHeaders(entry, headers);
+    for (const [name, wire] of Object.entries(entry.query ?? {})) {
+        const found = url.searchParams.getAll(wire);
+        if (found.length !== 1)
+            invalidRequest(`Query parameter ${wire} must occur exactly once.`);
+        values[name] = decodeScalar(entry, name, found[0], domain);
+    }
+    for (const [name, pick] of Object.entries(entry.headers ?? {})) {
+        if (pick === '*') {
+            const explicit = specificHeaderWires(entry);
+            values[name] = Object.fromEntries(Object.entries(applicationHeaders).filter(([header]) => !explicit.has(header) &&
+                header !== 'accept' &&
+                !isReservedHeader(header) &&
+                (entry.body === undefined || header !== 'content-type')));
+        }
+        else {
+            const value = headers[pick.toLowerCase()];
+            if (value === undefined)
+                invalidRequest(`Missing header ${pick}.`);
+            values[name] = decodeScalar(entry, name, value, domain);
+        }
+    }
+    if (entry.body === '*') {
+        const body = parseJsonObject(request.body);
+        const allowed = remainderFields(entry, domain);
+        for (const name of Object.keys(body)) {
+            if (!allowed.has(name)) {
+                invalidRequest(`JSON body field ${name} is not owned by the route remainder mapping.`);
+            }
+        }
+        Object.assign(values, body);
+    }
+    else if (entry.body !== undefined) {
+        const needsText = Object.values(entry.body).some((pick) => typeof pick !== 'string');
+        const body = needsText ? bodyText(request.body) : parseJsonObject(request.body);
+        for (const [name, pick] of Object.entries(entry.body)) {
+            if (typeof pick !== 'string') {
+                values[name] = body;
+            }
+            else {
+                const value = body[pick];
+                if (value === undefined)
+                    invalidRequest(`Missing JSON body field ${pick}.`);
+                values[name] = value;
+            }
+        }
+    }
+    let receiver;
+    if (requiresReceiver(entry)) {
+        const receiverName = entry.target.kind === 'method' && entry.target.dispatch === 'instance'
+            ? entry.target.receiver
+            : undefined;
+        const encodedReceiver = receiverName === undefined ? undefined : values[receiverName];
+        if (typeof encodedReceiver !== 'string')
+            invalidRequest('Instance route receiver is missing.');
+        try {
+            receiver = NodePath(encodedReceiver);
+        }
+        catch (cause) {
+            if (cause instanceof TypeError) {
+                return fail('NATIVE_ROUTE_REQUEST_INVALID', 'Instance route receiver is invalid.', cause);
+            }
+            throw cause;
+        }
+        delete values[receiverName];
+    }
+    let input;
+    try {
+        input = portable.accept(values);
+    }
+    catch (cause) {
+        if (cause instanceof portable.BoundaryError) {
+            return fail('NATIVE_ROUTE_REQUEST_INVALID', 'Native route input is not portable.', cause);
+        }
+        throw cause;
+    }
+    const coordinate = callableAddress(entry.callable);
+    const target = coordinate.kind === 'method'
+        ? receiver === undefined
+            ? Path.staticMethod(Path.project(coordinate.owner), coordinate.name).raw
+            : Path.instanceMethod(Path.from(receiver), coordinate.name).raw
+        : Path.project({
+            origin: coordinate.origin,
+            kind: 'function',
+            name: coordinate.name,
+        }).raw;
+    return Object.freeze({
+        call: Object.freeze({ target, input }),
+        ...(credential === undefined ? {} : { credential }),
+        ...(routing === undefined ? {} : { routing }),
+    });
+}
+function remainderFields(entry, domain) {
+    const claimed = new Set([
+        ...[...entry.href.matchAll(PLACEHOLDER)].map((item) => item[1]),
+        ...(entry.requestMethod === undefined ? [] : [entry.requestMethod]),
+        ...Object.keys(entry.query ?? {}),
+        ...Object.keys(entry.headers ?? {}),
+    ]);
+    const fields = domain.callable(entry.callable)?.inputFields ?? [];
+    const allowed = new Set(fields.filter((name) => !claimed.has(name)));
+    const receiver = entry.target.kind === 'method' && entry.target.dispatch === 'instance'
+        ? entry.target.receiver
+        : undefined;
+    if (receiver !== undefined && !claimed.has(receiver)) {
+        allowed.add(receiver);
+    }
+    return allowed;
+}

package/dist/routes/encode.d.ts

@@ -0,0 +1,4 @@
+import type { Domain } from '@astrale-os/kernel-dsl/v1';
+import type { Invocation, Request } from './request.js';
+import type { Route } from './table.js';
+export declare function encode(entry: Route, invocation: Invocation, domain: Domain): Request;

package/dist/routes/encode.js

@@ -0,0 +1,145 @@
+import { Path } from '@astrale-os/kernel-core/path';
+import { callableAddress } from '@astrale-os/kernel-dsl/v1/addressing';
+import * as portable from '@astrale-os/kernel-dsl/value';
+import { firstCredentialIsAmbient, putCredential, specificHeaderWires, withoutCredentialHeaders, } from './credential.js';
+import { fail, invalidRequest } from './error.js';
+import { isReservedHeader } from './mapping.js';
+import { encodeStrongEtag, HTTP_ROUTE_ISSUER, HTTP_ROUTE_PUBLICATION } from './routing.js';
+import { asObject, encodeScalar, scalar } from './scalar.js';
+import { requiresReceiver } from './target.js';
+import { authorityEnd, encodeTemplate, PLACEHOLDER } from './template.js';
+export function encode(entry, invocation, domain) {
+    const input = asObject(invocation.call.input);
+    const target = Path.from(invocation.call.target);
+    const needsReceiver = requiresReceiver(entry);
+    const coordinate = callableAddress(entry.callable);
+    const methodName = coordinate.kind === 'method' ? coordinate.name : undefined;
+    const receiver = needsReceiver ? instanceSource(target, methodName) : undefined;
+    const source = receiver?.raw;
+    const expected = needsReceiver
+        ? Path.instanceMethod(receiver, methodName).raw
+        : coordinate.kind === 'method'
+            ? Path.staticMethod(Path.project(coordinate.owner), methodName).raw
+            : Path.project({
+                origin: coordinate.origin,
+                kind: 'function',
+                name: coordinate.name,
+            }).raw;
+    if (target.raw !== expected)
+        invalidRequest('Invocation Path does not match the selected route.');
+    const receiverName = entry.target.kind === 'method' && entry.target.dispatch === 'instance'
+        ? entry.target.receiver
+        : undefined;
+    const field = (name) => (name === receiverName ? source : input[name]);
+    const wireField = (name) => encodeScalar(entry, name, field(name), domain);
+    const hostEnd = authorityEnd(entry.href);
+    let url = entry.href.replaceAll(PLACEHOLDER, (_whole, name, catchall, offset) => encodeTemplate(wireField(name), catchall, offset < hostEnd));
+    const parsed = new URL(url);
+    for (const [name, wire] of Object.entries(entry.query ?? {})) {
+        parsed.searchParams.append(wire, wireField(name));
+    }
+    let headers = {};
+    for (const [name, pick] of Object.entries(entry.headers ?? {})) {
+        if (pick !== '*')
+            headers[pick] = wireField(name);
+    }
+    const headerRemainder = Object.entries(entry.headers ?? {}).find(([, pick]) => pick === '*');
+    if (headerRemainder !== undefined) {
+        const explicit = specificHeaderWires(entry);
+        for (const [header, headerValue] of Object.entries(asObject(field(headerRemainder[0])))) {
+            const canonical = header.toLowerCase();
+            if (header !== canonical || explicit.has(canonical) || isReservedHeader(canonical)) {
+                invalidRequest('Wildcard header input overlaps an explicit, reserved, or non-canonical header name.');
+            }
+            headers[canonical] = scalar(headerValue);
+        }
+    }
+    let body;
+    if (entry.body === '*') {
+        const claimed = new Set([
+            ...[...entry.href.matchAll(PLACEHOLDER)].map((item) => item[1]),
+            ...(entry.requestMethod === undefined ? [] : [entry.requestMethod]),
+            ...Object.keys(entry.query ?? {}),
+            ...Object.keys(entry.headers ?? {}),
+        ]);
+        const output = {};
+        for (const [name, value] of Object.entries(input)) {
+            if (!claimed.has(name))
+                output[name] = value;
+        }
+        if (receiverName !== undefined && !claimed.has(receiverName)) {
+            output[receiverName] = source;
+        }
+        body = portable.json.serialize(output);
+        headers['content-type'] = 'application/json';
+    }
+    else if (entry.body !== undefined) {
+        const output = {};
+        for (const [name, pick] of Object.entries(entry.body)) {
+            if (typeof pick !== 'string')
+                body = scalar(field(name));
+            else
+                output[pick] = field(name);
+        }
+        if (body === undefined) {
+            body = portable.json.serialize(output);
+            headers['content-type'] = 'application/json';
+        }
+        else {
+            headers['content-type'] = 'text/plain; charset=utf-8';
+        }
+    }
+    headers = withoutCredentialHeaders(entry, headers);
+    const ambientCredential = firstCredentialIsAmbient(entry);
+    if (invocation.credential !== undefined && ambientCredential) {
+        invalidRequest('A cookie credential is ambient and cannot be emitted by JavaScript.');
+    }
+    if (invocation.credential !== undefined) {
+        putCredential(entry, parsed, headers, invocation.credential);
+    }
+    for (const name of Object.keys(headers)) {
+        if (isReservedHeader(name)) {
+            invalidRequest(`Header ${name} is reserved by the invocation protocol.`);
+        }
+    }
+    if (invocation.routing !== undefined) {
+        headers[HTTP_ROUTE_PUBLICATION] = encodeStrongEtag(invocation.routing.publication.etag);
+        headers[HTTP_ROUTE_ISSUER] = invocation.routing.issuer;
+    }
+    url = parsed.toString();
+    const mappedMethod = entry.requestMethod === undefined
+        ? undefined
+        : encodeScalar(entry, entry.requestMethod, input[entry.requestMethod], domain).toUpperCase();
+    const requestedMethod = invocation.method?.toUpperCase();
+    if (mappedMethod !== undefined &&
+        requestedMethod !== undefined &&
+        mappedMethod !== requestedMethod) {
+        invalidRequest('Native route request method differs from its mapped input field.');
+    }
+    const methodCandidate = entry.method === '*' ? (requestedMethod ?? mappedMethod) : entry.method;
+    if (methodCandidate === undefined) {
+        fail('NATIVE_ROUTE_REQUEST_INVALID', 'Wildcard route invocation requires an HTTP method.');
+    }
+    if (!['GET', 'POST', 'PUT', 'PATCH', 'DELETE'].includes(methodCandidate)) {
+        invalidRequest('Native route request method is unsupported.');
+    }
+    const method = methodCandidate;
+    if (mappedMethod !== undefined && mappedMethod !== method) {
+        invalidRequest('Native route input method does not match the declared route method.');
+    }
+    return Object.freeze({
+        url,
+        method,
+        headers: Object.freeze(headers),
+        ...(body === undefined ? {} : { body }),
+        ...(ambientCredential ? { credentials: 'include' } : {}),
+    });
+}
+function instanceSource(target, name) {
+    const steps = target.ast.steps;
+    const last = steps.at(-1);
+    if (last?.kind !== 'method' || last.dispatch !== 'instance' || last.name !== name) {
+        invalidRequest('Invocation Path is not the selected instance Method.');
+    }
+    return Path.fromAST({ anchor: target.ast.anchor, steps: steps.slice(0, -1) });
+}

package/dist/routes/error-response.d.ts

@@ -0,0 +1,5 @@
+import type { ErrorPayload } from '../errors/index.js';
+export interface ErrorResponse {
+    readonly error: ErrorPayload;
+}
+export declare function decodeErrorResponse(input: unknown): ErrorResponse;