@astrale-os/kernel-protocol 0.5.0-beta.5 → 0.5.0-beta.51

package/dist/publication/requirements.js

@@ -1,9 +1,14 @@
-import { KernelSchema } from '@astrale-os/kernel-core/schema';
 import { AuthorityOperationOrder } from '@astrale-os/kernel-core/schema/authority/operation';
-import { Key, patterns, Ref } from '@astrale-os/kernel-dsl/v1/addressing';
-import { revisionOfDomainSchema } from '@astrale-os/kernel-dsl/v1/schema/revision';
+import { acceptDefinitionRef, callableAddress, Key } from '@astrale-os/kernel-dsl/v1/addressing';
+import { isMethodExecutable } from '@astrale-os/kernel-dsl/v1/language';
+import { revision } from '@astrale-os/kernel-dsl/v1/schema/revision';
 import { array, deepFreeze, exact, record, unique } from './content.js';
 import { fail } from './error.js';
+const KernelIdentityClass = Object.freeze({
+    origin: 'kernel.astrale.ai',
+    kind: 'class',
+    name: 'Identity',
+});
 export const ClassOperationOrder = Object.freeze([
     'create',
     'read',
@@ -11,12 +16,12 @@ export const ClassOperationOrder = Object.freeze([
     'update',
     'delete',
 ]);
-/** Admit the exact closed Publication v2 requirements object. */
+/** Admit the exact closed canonical requirements object used by Publication v3. */
 export function admitRequirements(input) {
     const requirements = record(input, 'PUBLICATION_INVALID', 'Publication requirements are invalid.');
     exact(requirements, ['capabilities'], 'PUBLICATION_INVALID');
     const capabilities = record(requirements.capabilities, 'PUBLICATION_INVALID', 'Publication capability requirements are invalid.');
-    exact(capabilities, ['admin', 'classes', 'functions'], 'PUBLICATION_INVALID');
+    exact(capabilities, ['authority', 'classes', 'functions', 'core'], 'PUBLICATION_INVALID');
     const functions = capabilities.functions === undefined
         ? undefined
         : nonEmpty(capabilities.functions, 'Function capability requirements').map(admitCallable);
@@ -31,7 +36,16 @@ export function admitRequirements(input) {
         unique(classes.map((entry) => classKey(entry.class)), 'PUBLICATION_INVALID', 'Class capability requirement');
         canonical(classes, (left, right) => compare(classKey(left.class), classKey(right.class)), 'Class capability requirements');
     }
-    const admin = capabilities.admin === undefined ? undefined : admitAdminRequirements(capabilities.admin);
+    const authority = capabilities.authority === undefined
+        ? undefined
+        : admitAuthorityRequirements(capabilities.authority);
+    const core = capabilities.core === undefined
+        ? undefined
+        : nonEmpty(capabilities.core, 'Core capability requirements').map(admitCoreCapabilityRequirement);
+    if (core !== undefined) {
+        unique(core.map(({ subject }) => Key.of(subject)), 'PUBLICATION_INVALID', 'Core capability subject');
+        canonical(core, (left, right) => compare(Key.of(left.subject), Key.of(right.subject)), 'Core capability requirements');
+    }
     return deepFreeze({
         capabilities: {
             ...(functions === undefined
@@ -40,35 +54,113 @@ export function admitRequirements(input) {
             ...(classes === undefined
                 ? {}
                 : { classes: Object.freeze(classes) }),
-            ...(admin === undefined ? {} : { admin }),
+            ...(authority === undefined ? {} : { authority }),
+            ...(core === undefined
+                ? {}
+                : { core: Object.freeze(core) }),
         },
     });
 }
+function admitCoreCapabilityRequirement(input) {
+    const requirement = record(input, 'PUBLICATION_INVALID', 'Core capability requirement is invalid.');
+    exact(requirement, ['authority', 'classes', 'functions', 'subject'], 'PUBLICATION_INVALID');
+    const subject = admitCoreRef(requirement.subject);
+    const functions = requirement.functions === undefined
+        ? undefined
+        : nonEmpty(requirement.functions, 'Core capability Function requirements').map(admitCallable);
+    if (functions !== undefined) {
+        unique(functions, 'PUBLICATION_INVALID', 'Core capability Function requirement');
+        canonical(functions, compare, 'Core capability Function requirements');
+    }
+    const classes = requirement.classes === undefined
+        ? undefined
+        : nonEmpty(requirement.classes, 'Core capability Class requirements').map(admitClassRequirement);
+    if (classes !== undefined) {
+        unique(classes.map((entry) => classKey(entry.class)), 'PUBLICATION_INVALID', 'Core capability Class requirement');
+        canonical(classes, (left, right) => compare(classKey(left.class), classKey(right.class)), 'Core capability Class requirements');
+    }
+    const authority = requirement.authority === undefined
+        ? undefined
+        : admitAuthorityRequirements(requirement.authority);
+    if (functions === undefined && classes === undefined && authority === undefined) {
+        fail('PUBLICATION_INVALID', 'Core capability requirements cannot be empty.');
+    }
+    return Object.freeze({
+        subject,
+        ...(functions === undefined
+            ? {}
+            : { functions: Object.freeze(functions) }),
+        ...(classes === undefined
+            ? {}
+            : { classes: Object.freeze(classes) }),
+        ...(authority === undefined ? {} : { authority }),
+    });
+}
 /** Bind explicit capability targets to exact functional dependencies in the bundle closure. */
 export function validateRequirements(root, closure, requirements) {
     const dependencies = exactDependencyClosure(root, closure);
     for (const callable of requirements.capabilities.functions ?? []) {
         const dependency = capabilityOwner(root, dependencies, callable, 'Function');
-        const reference = Key.ref(callable);
-        if (!hasCallable(dependency, reference)) {
+        if (!hasCallable(dependency, callable)) {
             fail('PUBLICATION_INVALID', 'Function capability requirement names an unknown dependency callable.');
         }
     }
     for (const requirement of requirements.capabilities.classes ?? []) {
-        const key = Key.fromSchema(requirement.class);
+        const key = Key.of(requirement.class);
         const dependency = capabilityOwner(root, dependencies, key, 'Class');
         if (dependency.classes[requirement.class.name] === undefined) {
             fail('PUBLICATION_INVALID', 'Class capability requirement names an unknown dependency Class.');
         }
     }
+    for (const requirement of requirements.capabilities.core ?? []) {
+        const subject = root.core.nodes[requirement.subject.name];
+        if (requirement.subject.origin !== root.origin ||
+            subject === undefined ||
+            !classSatisfies(root, dependencies, subject.class, KernelIdentityClass)) {
+            fail('PUBLICATION_INVALID', 'Core capability subject must name one local Core Identity.');
+        }
+        for (const callable of requirement.functions ?? []) {
+            const owner = Key.origin(callable) === root.origin
+                ? root
+                : capabilityOwner(root, dependencies, callable, 'Function');
+            if (!hasCallable(owner, callable)) {
+                fail('PUBLICATION_INVALID', 'Core capability Function requirement names an unknown or non-executable callable.');
+            }
+        }
+        for (const classRequirement of requirement.classes ?? []) {
+            const key = Key.of(classRequirement.class);
+            const owner = classRequirement.class.origin === root.origin
+                ? root
+                : capabilityOwner(root, dependencies, key, 'Class');
+            if (owner.classes[classRequirement.class.name] === undefined) {
+                fail('PUBLICATION_INVALID', 'Core capability Class requirement names an unknown dependency Class.');
+            }
+        }
+    }
+}
+function classSatisfies(root, dependencies, candidate, expected) {
+    const expectedKey = Key.of(expected);
+    const visited = new Set();
+    const visit = (reference) => {
+        const key = Key.of(reference);
+        if (key === expectedKey)
+            return true;
+        if (visited.has(key))
+            return false;
+        visited.add(key);
+        const owner = reference.origin === root.origin ? root : dependencies.get(reference.origin);
+        const definition = owner?.classes[reference.name];
+        return definition?.kind === 'node' && definition.extends.some(visit);
+    };
+    return visit(candidate);
 }
 function exactDependencyClosure(root, closure) {
     const supplied = new Map(closure.map((dependency) => [dependency.origin, dependency]));
     const reachable = new Map();
     const visit = (owner) => {
-        for (const coordinate of owner.dependencies) {
+        for (const coordinate of Object.values(owner.dependencies)) {
             const dependency = supplied.get(coordinate.origin);
-            if (dependency === undefined || revisionOfDomainSchema(dependency) !== coordinate.revision) {
+            if (dependency === undefined || revision(dependency) !== coordinate.revision) {
                 fail('PUBLICATION_INVALID', 'Publication Bundle omits an exact dependency.');
             }
             if (reachable.has(dependency.origin))
@@ -84,8 +176,10 @@ function admitCallable(input) {
     if (typeof input !== 'string' || !Key.is(input)) {
         return fail('PUBLICATION_INVALID', 'Function capability reference is invalid.');
     }
-    const reference = Key.ref(input);
-    if (!reference.startsWith('function.') && !Ref.isMethod(reference)) {
+    try {
+        callableAddress(input);
+    }
+    catch {
         return fail('PUBLICATION_INVALID', 'Function capability reference must name a Function or Method.');
     }
     return input;
@@ -101,14 +195,14 @@ function admitClassRequirement(input) {
         operations: Object.freeze(operations),
     });
 }
-function admitAdminRequirements(input) {
-    const admin = record(input, 'PUBLICATION_INVALID', 'Administrative capability requirements are invalid.');
-    exact(admin, ['grant', 'revoke'], 'PUBLICATION_INVALID');
-    if (admin.grant === undefined && admin.revoke === undefined) {
-        fail('PUBLICATION_INVALID', 'Administrative capability requirements cannot be empty.');
+function admitAuthorityRequirements(input) {
+    const authority = record(input, 'PUBLICATION_INVALID', 'Authority capability requirements are invalid.');
+    exact(authority, ['grant', 'revoke'], 'PUBLICATION_INVALID');
+    if (authority.grant === undefined && authority.revoke === undefined) {
+        fail('PUBLICATION_INVALID', 'Authority capability requirements cannot be empty.');
     }
-    const grant = admitAuthorityOperations(admin.grant, 'grant');
-    const revoke = admitAuthorityOperations(admin.revoke, 'revoke');
+    const grant = admitAuthorityOperations(authority.grant, 'grant');
+    const revoke = admitAuthorityOperations(authority.revoke, 'revoke');
     return Object.freeze({
         ...(grant === undefined ? {} : { grant }),
         ...(revoke === undefined ? {} : { revoke }),
@@ -117,22 +211,35 @@ function admitAdminRequirements(input) {
 function admitAuthorityOperations(input, kind) {
     if (input === undefined)
         return undefined;
-    const values = nonEmpty(input, `Administrative ${kind} operations`).map((entry) => admitOperation(entry, AuthorityOperationOrder, `Administrative ${kind} operation`));
-    unique(values, 'PUBLICATION_INVALID', `administrative ${kind} operation`);
-    canonical(values, ordered(AuthorityOperationOrder), `Administrative ${kind} operations`);
+    const values = nonEmpty(input, `Authority ${kind} operations`).map((entry) => admitOperation(entry, AuthorityOperationOrder, `Authority ${kind} operation`));
+    unique(values, 'PUBLICATION_INVALID', `authority ${kind} operation`);
+    canonical(values, ordered(AuthorityOperationOrder), `Authority ${kind} operations`);
     return Object.freeze(values);
 }
 function admitClassRef(input) {
-    const value = record(input, 'PUBLICATION_INVALID', 'Class capability reference is invalid.');
-    exact(value, ['kind', 'name', 'origin'], 'PUBLICATION_INVALID');
-    if (value.kind !== 'class' ||
-        typeof value.origin !== 'string' ||
-        !patterns.origin.test(value.origin) ||
-        typeof value.name !== 'string' ||
-        !patterns.memberName.test(value.name)) {
+    let value;
+    try {
+        value = acceptDefinitionRef(input);
+    }
+    catch {
         fail('PUBLICATION_INVALID', 'Class capability reference is invalid.');
     }
-    return Object.freeze({ origin: value.origin, kind: 'class', name: value.name });
+    if (value.kind !== 'class')
+        fail('PUBLICATION_INVALID', 'Class capability reference is invalid.');
+    return value;
+}
+function admitCoreRef(input) {
+    let value;
+    try {
+        value = acceptDefinitionRef(input);
+    }
+    catch {
+        fail('PUBLICATION_INVALID', 'Core capability subject is invalid.');
+    }
+    if (value.kind !== 'core') {
+        fail('PUBLICATION_INVALID', 'Core capability subject must be one local Core reference.');
+    }
+    return value;
 }
 function nonEmpty(input, label) {
     const values = [...array(input, 'PUBLICATION_INVALID')];
@@ -158,28 +265,23 @@ function compare(left, right) {
     return left < right ? -1 : left > right ? 1 : 0;
 }
 function classKey(input) {
-    return String(Key.fromSchema(input));
+    return String(Key.of(input));
 }
 function capabilityOwner(root, dependencies, key, label) {
     const origin = Key.origin(key);
     if (origin === root.origin)
         fail('PUBLICATION_INVALID', `${label} capability target cannot be local.`);
-    if (origin === KernelSchema.origin)
-        return KernelSchema;
     const dependency = dependencies.get(origin);
     if (dependency === undefined) {
         fail('PUBLICATION_INVALID', `${label} capability target must belong to the exact dependency closure.`);
     }
     return dependency;
 }
-function hasCallable(dependency, reference) {
-    if (reference.startsWith('function.')) {
-        return dependency.functions[Ref.member(reference)] !== undefined;
-    }
-    const ownerKind = Ref.namespace(reference);
-    const owner = Ref.member(reference);
-    const method = Ref.child(reference);
-    const declaration = ownerKind === 'class' ? dependency.classes[owner] : dependency.interfaces[owner];
-    return declaration?.family === 'node' && declaration.methods[method] !== undefined;
+function hasCallable(dependency, callable) {
+    const coordinate = callableAddress(callable);
+    if (coordinate.kind === 'function')
+        return dependency.functions[coordinate.name] !== undefined;
+    const declaration = dependency.classes[coordinate.owner.name];
+    const method = declaration?.kind === 'node' ? declaration.methods[coordinate.name] : undefined;
+    return method !== undefined && isMethodExecutable(declaration, method);
 }
-//# sourceMappingURL=requirements.js.map

package/dist/publication/route.d.ts

@@ -35,4 +35,3 @@ export interface HttpRouteDeclaration extends Omit<HttpRoute, 'href'> {
 }
 export declare function admitRoute(input: unknown, origin: string): HttpRoute;
 export declare function admitRouteDeclaration(input: unknown, origin: string): HttpRouteDeclaration;
-//# sourceMappingURL=route.d.ts.map

package/dist/publication/route.js

@@ -152,4 +152,3 @@ function stringRecord(input) {
     }
     return Object.freeze(output);
 }
-//# sourceMappingURL=route.js.map

package/dist/publication/schema.d.ts

@@ -1,8 +1,7 @@
-import type { Revision } from '@astrale-os/kernel-dsl/v1/schema';
+import type { Revision } from '@astrale-os/kernel-dsl/v1/addressing';
 import type { BundleDescriptor } from './bundle-descriptor.js';
 export interface Schema {
     readonly revision: Revision;
     readonly bundle: BundleDescriptor;
 }
 export declare function admitSchema(input: unknown): Schema;
-//# sourceMappingURL=schema.d.ts.map

package/dist/publication/schema.js

@@ -13,4 +13,3 @@ export function admitSchema(input) {
         bundle: admitBundleDescriptor(value.bundle),
     });
 }
-//# sourceMappingURL=schema.js.map

package/dist/routes/admission.d.ts

@@ -1,4 +1,3 @@
 import type { Table } from './table.js';
 /** Admit one emitted portable Table before Server composition. */
 export declare function acceptTable(input: unknown): Table;
-//# sourceMappingURL=admission.d.ts.map

package/dist/routes/admission.js

@@ -2,7 +2,7 @@ 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 AUTHENTICATION = new Set(['anonymous', 'authenticated', 'authorized']);
+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) {
@@ -19,11 +19,11 @@ export function acceptTable(input) {
 }
 function acceptRoute(input, origin) {
     const value = object(input, 'Route Table entry');
-    exact(value, ['name', 'callable', 'target', 'authentication', 'output', 'href', 'method', 'default'], 'Route Table entry', ['requestMethod', 'query', 'headers', 'body', 'credential']);
+    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.authentication !== 'string' || !AUTHENTICATION.has(value.authentication)) {
-        invalid('Route Table authentication');
+    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');
@@ -44,7 +44,7 @@ function acceptRoute(input, origin) {
     return Object.freeze({
         ...common,
         target: target(value.target),
-        authentication: value.authentication,
+        auth: value.auth,
         output: value.output,
         default: value.default,
     });
@@ -87,4 +87,3 @@ function exact(value, required, label, optional = []) {
 function invalid(label) {
     return fail('NATIVE_ROUTE_BINDING_INVALID', `${label} is invalid.`);
 }
-//# sourceMappingURL=admission.js.map

package/dist/routes/binding.d.ts

@@ -1,7 +1,6 @@
-import type { schema } from '@astrale-os/kernel-dsl/v1';
+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 Validator. */
-export declare function bind(plan: Plan, deployed: Publication, validator: schema.Validator): Table;
-//# sourceMappingURL=binding.d.ts.map
+/** 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

@@ -3,13 +3,13 @@ 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 Validator. */
-export function bind(plan, deployed, validator) {
+/** 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 !== validator.origin ||
+        plan.origin !== domain.origin ||
         plan.revision !== deployed.schema.revision ||
-        plan.revision !== validator.revision) {
-        fail('NATIVE_ROUTE_BINDING_INVALID', 'Route Plan, Publication, and Validator identity differ.');
+        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)) {
@@ -25,4 +25,3 @@ export function bind(plan, deployed, validator) {
         entries: Object.freeze(entries),
     });
 }
-//# sourceMappingURL=binding.js.map

package/dist/routes/collision.d.ts

@@ -1,3 +1,2 @@
 import type { Route } from './table.js';
 export declare function rejectCollisions(entries: readonly Route[]): void;
-//# sourceMappingURL=collision.d.ts.map

package/dist/routes/collision.js

@@ -14,4 +14,3 @@ export function rejectCollisions(entries) {
 function overlap(left, right) {
     return left === '*' || right === '*' || left === right;
 }
-//# sourceMappingURL=collision.js.map

package/dist/routes/compiler.d.ts

@@ -1,9 +1,8 @@
-import type { schema } from '@astrale-os/kernel-dsl/v1';
+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 validator: schema.Validator;
+    readonly domain: Domain;
 }
 export declare function compile(input: CompileInput): Plan;
-//# sourceMappingURL=compiler.d.ts.map

package/dist/routes/compiler.js

@@ -8,41 +8,43 @@ 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.validator.origin));
+    const authored = input.routes.map((entry) => admitRouteDeclaration(entry, input.domain.origin));
     const entries = authored.map((declaration) => {
-        const meaning = input.validator.callable(declaration.callable);
-        if (meaning === undefined) {
-            fail('NATIVE_ROUTE_BINDING_INVALID', `Unknown callable ${declaration.callable}.`);
+        const meaning = input.domain.callable(declaration.callable);
+        if (meaning === undefined || (isMethod(meaning) && !meaning.executable)) {
+            fail('NATIVE_ROUTE_BINDING_INVALID', `Unavailable callable ${declaration.callable}.`);
         }
         const href = placePath(declaration.path, 'https://routes.invalid');
         const route = { ...declaration, href };
         validateTemplate(href);
-        validateMapping(route, meaning.fields, meaning.target.kind === 'method' && meaning.target.dispatch === 'instance');
+        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 = meaning.target.kind === 'function'
+        const target = !isMethod(meaning)
             ? { kind: 'function' }
-            : meaning.target.dispatch === 'static'
+            : 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,
-            authentication: meaning.authentication,
-            output: meaning.output,
+            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.validator.origin,
-        revision: input.validator.revision,
+        origin: input.domain.origin,
+        revision: input.domain.revision,
         entries: Object.freeze(entries),
     });
 }
-//# sourceMappingURL=compiler.js.map
+function isMethod(meaning) {
+    return 'owner' in meaning;
+}

package/dist/routes/credential.d.ts

@@ -6,4 +6,3 @@ 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;
-//# sourceMappingURL=credential.d.ts.map

package/dist/routes/credential.js

@@ -116,4 +116,3 @@ function withoutCookie(header, name) {
         .join('; ');
     return value.length === 0 ? undefined : value;
 }
-//# sourceMappingURL=credential.js.map

package/dist/routes/decode.d.ts

@@ -1,6 +1,5 @@
-import type { schema } from '@astrale-os/kernel-dsl/v1';
+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, validator: schema.Validator, served: PublicationRef): Invocation;
-//# sourceMappingURL=decode.d.ts.map
+export declare function decode(entry: Route, request: HttpRequest, domain: Domain, served: PublicationRef): Invocation;

package/dist/routes/decode.js

@@ -1,5 +1,4 @@
-import { NodePath, Path } from '@astrale-os/kernel-core/path';
-import { Key, Ref } from '@astrale-os/kernel-dsl/v1/addressing';
+import { NodePath } from '@astrale-os/kernel-core/path';
 import * as portable from '@astrale-os/kernel-dsl/value';
 import { readCredential, specificHeaderWires, withoutCredentialHeaders } from './credential.js';
 import { fail, invalidRequest } from './error.js';
@@ -10,7 +9,7 @@ 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, validator, served) {
+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);
@@ -18,10 +17,10 @@ export function decode(entry, request, validator, served) {
         invalidRequest('URL does not match the route template.');
     const values = {};
     for (const [name, value] of Object.entries(matched)) {
-        values[name] = decodeScalar(entry, name, value, validator);
+        values[name] = decodeScalar(entry, name, value, domain);
     }
     if (entry.requestMethod !== undefined) {
-        values[entry.requestMethod] = decodeScalar(entry, entry.requestMethod, request.method.toUpperCase(), validator);
+        values[entry.requestMethod] = decodeScalar(entry, entry.requestMethod, request.method.toUpperCase(), domain);
     }
     let url;
     try {
@@ -41,7 +40,7 @@ export function decode(entry, request, validator, served) {
         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], validator);
+        values[name] = decodeScalar(entry, name, found[0], domain);
     }
     for (const [name, pick] of Object.entries(entry.headers ?? {})) {
         if (pick === '*') {
@@ -55,12 +54,12 @@ export function decode(entry, request, validator, served) {
             const value = headers[pick.toLowerCase()];
             if (value === undefined)
                 invalidRequest(`Missing header ${pick}.`);
-            values[name] = decodeScalar(entry, name, value, validator);
+            values[name] = decodeScalar(entry, name, value, domain);
         }
     }
     if (entry.body === '*') {
         const body = parseJsonObject(request.body);
-        const allowed = remainderFields(entry, validator);
+        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.`);
@@ -112,34 +111,25 @@ export function decode(entry, request, validator, served) {
         }
         throw cause;
     }
-    const ref = Key.ref(entry.callable);
-    const target = Ref.isMethod(ref)
-        ? receiver === undefined
-            ? Path.staticMethod(Path.project({
-                origin: Key.origin(entry.callable),
-                kind: Ref.namespace(ref),
-                name: Ref.member(ref),
-            }), Ref.child(ref)).raw
-            : Path.instanceMethod(Path.from(receiver), Ref.child(ref)).raw
-        : Path.project({
-            origin: Key.origin(entry.callable),
-            kind: 'function',
-            name: Ref.member(ref),
-        }).raw;
+    const target = Object.freeze({
+        callable: entry.callable,
+        revision: domain.revision,
+        ...(receiver === undefined ? {} : { instance: receiver }),
+    });
     return Object.freeze({
         call: Object.freeze({ target, input }),
         ...(credential === undefined ? {} : { credential }),
         ...(routing === undefined ? {} : { routing }),
     });
 }
-function remainderFields(entry, validator) {
+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 = validator.callable(entry.callable)?.fields ?? [];
+    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
@@ -149,4 +139,3 @@ function remainderFields(entry, validator) {
     }
     return allowed;
 }
-//# sourceMappingURL=decode.js.map

package/dist/routes/encode.d.ts

@@ -1,5 +1,4 @@
-import type { schema } from '@astrale-os/kernel-dsl/v1';
+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, validator: schema.Validator): Request;
-//# sourceMappingURL=encode.d.ts.map
+export declare function encode(entry: Route, invocation: Invocation, domain: Domain): Request;