@astrale-os/kernel-protocol 0.5.0-beta.2 → 0.5.0-beta.21

package/dist/publication/delivery/request.js

@@ -1,4 +1,5 @@
-import * as auth from '@astrale-os/kernel-core/auth';
+import { AuthValueError } from '@astrale-os/kernel-core/auth/error';
+import { accept as acceptIssuer } from '@astrale-os/kernel-core/auth/issuer';
 import { fail } from './error.js';
 import { NONCE_MAX_LENGTH, NONCE_MIN_LENGTH } from './limits.js';
 /** Admit the exact request representation accepted by a Delivery transport boundary. */
@@ -34,10 +35,10 @@ export function acceptRequest(input) {
     }
     let kernel;
     try {
-        kernel = auth.issuer.accept(value.kernel);
+        kernel = acceptIssuer(value.kernel);
     }
     catch (cause) {
-        if (cause instanceof auth.AuthValueError) {
+        if (cause instanceof AuthValueError) {
             return fail('DELIVERY_REQUEST_INVALID', 'Delivery request issuer is invalid.', cause);
         }
         throw cause;
@@ -49,4 +50,3 @@ export function acceptRequest(input) {
         etag: value.etag,
     });
 }
-//# sourceMappingURL=request.js.map

package/dist/publication/delivery-declaration.d.ts

@@ -0,0 +1,4 @@
+import type { DeliveryDeclaration } from './declaration.js';
+import type { Endpoint } from './delivery-endpoint.js';
+/** Place one provider-neutral Delivery declaration beneath an exact serving issuer. */
+export declare function placeDelivery(input: DeliveryDeclaration, issuer: string, bundleHref: string): Endpoint;

package/dist/publication/delivery-declaration.js

@@ -0,0 +1,25 @@
+import { admitEndpoint } from './delivery-endpoint.js';
+import { fail } from './error.js';
+/** Place one provider-neutral Delivery declaration beneath an exact serving issuer. */
+export function placeDelivery(input, issuer, bundleHref) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        fail('PUBLICATION_INVALID', 'Delivery declaration is invalid.');
+    }
+    if (Reflect.ownKeys(input).some((key) => key !== 'path' && key !== 'authentication') ||
+        typeof input.path !== 'string' ||
+        !input.path.startsWith('/')) {
+        fail('PUBLICATION_INVALID', 'Delivery declaration is invalid.');
+    }
+    let href;
+    try {
+        const url = new URL(input.path, issuer);
+        if (url.origin !== new URL(issuer).origin || url.search !== '' || url.hash !== '') {
+            fail('PUBLICATION_INVALID', 'Delivery declaration must be one relative path.');
+        }
+        href = url.href;
+    }
+    catch (cause) {
+        return fail('PUBLICATION_INVALID', 'Delivery declaration path is invalid.', cause);
+    }
+    return admitEndpoint({ href, method: 'POST', authentication: input.authentication }, bundleHref);
+}

package/dist/publication/delivery-endpoint.d.ts

@@ -9,4 +9,3 @@ export interface Endpoint {
     readonly authentication: Authentication;
 }
 export declare function admitEndpoint(input: unknown, publicUrl: string): Endpoint | undefined;
-//# sourceMappingURL=delivery-endpoint.d.ts.map

package/dist/publication/delivery-endpoint.js

@@ -20,4 +20,3 @@ export function admitEndpoint(input, publicUrl) {
         authentication: Object.freeze({ kind: authentication.kind }),
     });
 }
-//# sourceMappingURL=delivery-endpoint.js.map

package/dist/publication/error.d.ts

@@ -5,4 +5,3 @@ export declare class PublicationError extends Error {
     constructor(code: PublicationErrorCode, message: string, options?: ErrorOptions);
 }
 export declare function fail(code: PublicationErrorCode, message: string, cause?: unknown): never;
-//# sourceMappingURL=error.d.ts.map

package/dist/publication/error.js

@@ -9,4 +9,3 @@ export class PublicationError extends Error {
 export function fail(code, message, cause) {
     throw new PublicationError(code, message, cause === undefined ? undefined : { cause });
 }
-//# sourceMappingURL=error.js.map

package/dist/publication/etag.d.ts

@@ -4,4 +4,3 @@ export type Etag = Sha256Digest;
 export declare function admitDigest(input: unknown): Sha256Digest;
 export declare function computeEtag(input: Content): Etag;
 export declare function sha256Hex(input: Uint8Array): string;
-//# sourceMappingURL=etag.d.ts.map

package/dist/publication/etag.js

@@ -77,4 +77,3 @@ const ROUND = new Uint32Array([
     0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
     0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
 ]);
-//# sourceMappingURL=etag.js.map

package/dist/publication/index.d.ts

@@ -1,6 +1,10 @@
-export { MEDIA_TYPE, PATH, url, seal, accept, encode, acceptBundle, decodeBundle, type Publication, } from './publication.js';
+export { MEDIA_TYPE, PATH, url, seal, accept, encode, type Publication } from './publication.js';
+export { acceptBundle, decodeBundle } from './bundle-admission.js';
 export { BUNDLE_MEDIA_TYPE, describeBundle, type BundleDescriptor } from './bundle.js';
+export { verifyBundleBytes } from './bundle-evidence.js';
 export type { Content } from './content.js';
+export type { Declaration, DeliveryDeclaration } from './declaration.js';
+export { placeDelivery } from './delivery-declaration.js';
 export type { Etag, Sha256Digest } from './etag.js';
 export { PublicationError, type PublicationErrorCode } from './error.js';
 export * as delivery from './delivery/index.js';
@@ -8,7 +12,6 @@ export type { Authentication as DeliveryAuthentication, Endpoint as DeliveryEndp
 export type { Manifest } from './manifest.js';
 export { ClassOperationOrder, admitRequirements, validateRequirements, type CapabilityAdminRequirements, type CapabilityRequirements, type ClassCapabilityRequirement, type ClassOperation, type NonEmpty, type PublicationRequirements, } from './requirements.js';
 export { acceptReference, compareReference, compareReferences, matchesReference, reference, type PublicationRef, type PublicationReferenceRelation, } from './reference.js';
-export type { BodyPick, CredentialSource, HttpMethod, HttpRoute, RouteBody, RouteHeaders, SingleCredentialSource, } from './route.js';
+export type { BodyPick, CredentialSource, HttpMethod, HttpRoute, HttpRouteDeclaration, RouteBody, RouteHeaders, SingleCredentialSource, } from './route.js';
 export type { Schema } from './schema.js';
 export { acceptInvocationEndpoints, type CallableBinding, type InvocationEndpoints, type ViewBinding, } from './bindings/index.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/publication/index.js

@@ -1,8 +1,10 @@
-export { MEDIA_TYPE, PATH, url, seal, accept, encode, acceptBundle, decodeBundle, } from './publication.js';
+export { MEDIA_TYPE, PATH, url, seal, accept, encode } from './publication.js';
+export { acceptBundle, decodeBundle } from './bundle-admission.js';
 export { BUNDLE_MEDIA_TYPE, describeBundle } from './bundle.js';
+export { verifyBundleBytes } from './bundle-evidence.js';
+export { placeDelivery } from './delivery-declaration.js';
 export { PublicationError } from './error.js';
 export * as delivery from './delivery/index.js';
 export { ClassOperationOrder, admitRequirements, validateRequirements, } from './requirements.js';
 export { acceptReference, compareReference, compareReferences, matchesReference, reference, } from './reference.js';
 export { acceptInvocationEndpoints, } from './bindings/index.js';
-//# sourceMappingURL=index.js.map

package/dist/publication/manifest.d.ts

@@ -1,7 +1,6 @@
-import { Ref } from '@astrale-os/kernel-dsl/v1';
+import { type ViewRef } from '@astrale-os/kernel-dsl/v1/addressing';
 export interface Manifest {
     readonly logo?: string;
-    readonly entrypoint?: Ref.View;
+    readonly entrypoint?: ViewRef;
 }
 export declare function admitManifest(input: unknown): Manifest | undefined;
-//# sourceMappingURL=manifest.d.ts.map

package/dist/publication/manifest.js

@@ -1,4 +1,4 @@
-import { Ref } from '@astrale-os/kernel-dsl/v1';
+import { acceptDefinitionRef } from '@astrale-os/kernel-dsl/v1/addressing';
 import { exact, record } from './content.js';
 import { fail } from './error.js';
 export function admitManifest(input) {
@@ -11,16 +11,20 @@ export function admitManifest(input) {
     }
     let entrypoint;
     if (value.entrypoint !== undefined) {
-        if (typeof value.entrypoint !== 'string' ||
-            !Ref.isDefinition(value.entrypoint) ||
-            !value.entrypoint.startsWith('view.')) {
+        let ref;
+        try {
+            ref = acceptDefinitionRef(value.entrypoint);
+        }
+        catch (cause) {
+            return fail('PUBLICATION_INVALID', 'Manifest entrypoint must be a root View reference.', cause);
+        }
+        if (ref.kind !== 'view') {
             fail('PUBLICATION_INVALID', 'Manifest entrypoint must be a root View reference.');
         }
-        entrypoint = value.entrypoint;
+        entrypoint = ref;
     }
     return Object.freeze({
         ...(value.logo === undefined ? {} : { logo: value.logo }),
         ...(entrypoint === undefined ? {} : { entrypoint }),
     });
 }
-//# sourceMappingURL=manifest.js.map

package/dist/publication/publication.d.ts

@@ -1,5 +1,5 @@
-import * as auth from '@astrale-os/kernel-core/auth';
-import { Key, bundle as dslBundle } from '@astrale-os/kernel-dsl/v1';
+import { type IssuerId } from '@astrale-os/kernel-core/auth/issuer';
+import { Key } from '@astrale-os/kernel-dsl/v1/addressing';
 import type { CallableBinding, ViewBinding } from './bindings/index.js';
 import type { Content } from './content.js';
 import type { Endpoint as DeliveryEndpoint } from './delivery-endpoint.js';
@@ -17,7 +17,7 @@ export interface Publication {
     readonly version: 2;
     readonly origin: Key.Origin;
     readonly identity: {
-        readonly issuer: auth.IssuerId;
+        readonly issuer: IssuerId;
         readonly subject: string;
     };
     readonly etag: Etag;
@@ -34,6 +34,3 @@ export interface Publication {
 export declare function seal(input: Content): Publication;
 export declare function accept(input: unknown): Publication;
 export declare function encode(input: Publication): Uint8Array;
-export declare function acceptBundle(input: Publication, artifact: unknown): dslBundle.Bundle;
-export declare function decodeBundle(input: Publication, bytes: Uint8Array): dslBundle.Bundle;
-//# sourceMappingURL=publication.d.ts.map

package/dist/publication/publication.js

@@ -1,14 +1,14 @@
-import * as auth from '@astrale-os/kernel-core/auth';
-import { Key, Ref, bundle as dslBundle, schema as dslSchema, } from '@astrale-os/kernel-dsl/v1';
+import { AuthValueError } from '@astrale-os/kernel-core/auth/error';
+import { accept as acceptIssuerId } from '@astrale-os/kernel-core/auth/issuer';
+import { Key, patterns } from '@astrale-os/kernel-dsl/v1/addressing';
 import * as portable from '@astrale-os/kernel-dsl/value';
 import { admitCallableBinding, admitViewBinding } from './bindings/index.js';
-import { acceptBundleValue, decodeBundleValue, verifyBundleBytes } from './bundle.js';
 import { array, deepFreeze, exact, record, unique } from './content.js';
 import { admitEndpoint as admitDeliveryEndpoint } from './delivery-endpoint.js';
 import { fail } from './error.js';
 import { admitDigest, computeEtag } from './etag.js';
 import { admitManifest } from './manifest.js';
-import { admitRequirements, validateRequirements } from './requirements.js';
+import { admitRequirements } from './requirements.js';
 import { admitRoute } from './route.js';
 import { admitSchema } from './schema.js';
 export const PATH = '/.well-known/astrale/domain.json';
@@ -45,17 +45,6 @@ export function accept(input) {
 export function encode(input) {
     return portable.json.encode(input);
 }
-export function acceptBundle(input, artifact) {
-    const accepted = acceptBundleValue(artifact);
-    verifyBundleBytes(input, dslBundle.encode(accepted));
-    validateBundleInventory(input, accepted);
-    return accepted;
-}
-export function decodeBundle(input, bytes) {
-    const decoded = decodeBundleValue(input, bytes);
-    validateBundleInventory(input, decoded);
-    return decoded;
-}
 function acceptPublication(input, requireEtag) {
     const value = record(input, 'PUBLICATION_INVALID', 'Expected a Publication object.');
     exact(value, [
@@ -74,7 +63,7 @@ function acceptPublication(input, requireEtag) {
     if (value.format !== 'astrale.domain.publication' || value.version !== 2) {
         fail('PUBLICATION_INVALID', 'Unsupported Publication format or version.');
     }
-    if (typeof value.origin !== 'string' || !dslSchema.patterns.origin.test(value.origin)) {
+    if (typeof value.origin !== 'string' || !patterns.origin.test(value.origin)) {
         fail('PUBLICATION_INVALID', 'Publication origin is invalid.');
     }
     const origin = value.origin;
@@ -101,7 +90,10 @@ function acceptPublication(input, requireEtag) {
         }
     }
     if (manifest?.entrypoint !== undefined) {
-        const key = Key.of(origin, manifest.entrypoint);
+        if (manifest.entrypoint.origin !== origin) {
+            fail('PUBLICATION_VIEW_INVALID', 'Manifest entrypoint must belong to the root origin.');
+        }
+        const key = Key.of(manifest.entrypoint);
         if (!views.some(({ view }) => view === key)) {
             fail('PUBLICATION_VIEW_INVALID', 'Manifest entrypoint must have a published View binding.');
         }
@@ -124,60 +116,12 @@ function acceptPublication(input, requireEtag) {
         ...(delivery === undefined ? {} : { delivery }),
     });
 }
-function validateBundleInventory(publication, bundle) {
-    const root = bundle.root;
-    if (root.origin !== publication.origin ||
-        dslSchema.revision(root) !== publication.schema.revision) {
-        fail('PUBLICATION_INVALID', 'Bundle root does not match the Publication schema.');
-    }
-    validateRequirements(root, bundle.closure, publication.requirements);
-    const callables = concreteCallables(root);
-    const publishedCallables = new Set(publication.bindings.callables.map(({ callable }) => callable));
-    if (publishedCallables.size !== callables.size ||
-        [...callables].some((key) => !publishedCallables.has(key))) {
-        fail('PUBLICATION_BINDING_INVALID', 'Callable bindings must exhaust the root Domain.');
-    }
-    const views = new Set(Object.keys(root.views).map((name) => Key.of(root.origin, Ref.definition('view', name))));
-    const publishedViews = new Set(publication.bindings.views.map(({ view }) => view));
-    if (publishedViews.size !== views.size || [...views].some((key) => !publishedViews.has(key))) {
-        fail('PUBLICATION_VIEW_INVALID', 'View bindings must exhaust the root Domain.');
-    }
-    if (publication.manifest?.entrypoint !== undefined &&
-        root.views[Ref.member(publication.manifest.entrypoint)] === undefined) {
-        fail('PUBLICATION_INVALID', 'Manifest entrypoint does not exist in the root schema.');
-    }
-    for (const route of publication.routes) {
-        if (!callables.has(route.callable)) {
-            fail('PUBLICATION_ROUTE_INVALID', `Route ${route.name} names an unknown callable.`);
-        }
-    }
-}
-function concreteCallables(root) {
-    const result = new Set();
-    for (const name of Object.keys(root.functions)) {
-        result.add(Key.of(root.origin, Ref.definition('function', name)));
-    }
-    addConcreteMethods(result, root.origin, 'class', root.classes);
-    addConcreteMethods(result, root.origin, 'interface', root.interfaces);
-    return result;
-}
-function addConcreteMethods(result, origin, kind, definitions) {
-    for (const [owner, declaration] of Object.entries(definitions)) {
-        if (declaration.family !== 'node')
-            continue;
-        for (const [name, method] of Object.entries(declaration.methods)) {
-            if (method.inheritance === 'abstract')
-                continue;
-            result.add(Key.of(origin, Ref.method(Ref.definition(kind, owner), name)));
-        }
-    }
-}
 function admitIssuer(input) {
     try {
-        return auth.issuer.accept(String(input));
+        return acceptIssuerId(String(input));
     }
     catch (cause) {
-        if (cause instanceof auth.AuthValueError) {
+        if (cause instanceof AuthValueError) {
             return fail('PUBLICATION_INVALID', 'Publication issuer is invalid.', cause);
         }
         throw cause;
@@ -187,4 +131,3 @@ function withoutEtag(input) {
     const { etag: _etag, ...content } = input;
     return content;
 }
-//# sourceMappingURL=publication.js.map

package/dist/publication/reference.d.ts

@@ -1,11 +1,12 @@
-import { schema as dslSchema, type Key } from '@astrale-os/kernel-dsl/v1';
+import type { Revision } from '@astrale-os/kernel-dsl/v1/addressing';
+import { type Key } from '@astrale-os/kernel-dsl/v1/addressing';
 import type { Etag } from './etag.js';
 import type { Publication } from './publication.js';
 /** Compact untrusted projection that witnesses one exact Publication. */
 export interface PublicationRef {
     readonly origin: Key.Origin;
     readonly identity: Publication['identity'];
-    readonly revision: dslSchema.Revision;
+    readonly revision: Revision;
     readonly etag: Etag;
 }
 export type PublicationReferenceRelation = 'exact' | 'same-schema' | 'schema-drift' | 'identity-drift' | 'origin-drift';
@@ -14,4 +15,3 @@ export declare function acceptReference(input: unknown): PublicationRef;
 export declare function compareReferences(input: PublicationRef, expected: PublicationRef): PublicationReferenceRelation;
 export declare function compareReference(input: Publication, expected: PublicationRef): PublicationReferenceRelation;
 export declare function matchesReference(input: Publication, expected: PublicationRef): boolean;
-//# sourceMappingURL=reference.d.ts.map

package/dist/publication/reference.js

@@ -1,5 +1,6 @@
-import * as auth from '@astrale-os/kernel-core/auth';
-import { schema as dslSchema } from '@astrale-os/kernel-dsl/v1';
+import { AuthValueError } from '@astrale-os/kernel-core/auth/error';
+import { accept as acceptIssuerId } from '@astrale-os/kernel-core/auth/issuer';
+import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
 import { deepFreeze, exact, record } from './content.js';
 import { fail } from './error.js';
 import { admitDigest } from './etag.js';
@@ -14,7 +15,7 @@ export function reference(input) {
 export function acceptReference(input) {
     const value = record(input, 'PUBLICATION_INVALID', 'Publication reference is invalid.');
     exact(value, ['origin', 'identity', 'revision', 'etag'], 'PUBLICATION_INVALID');
-    if (typeof value.origin !== 'string' || !dslSchema.patterns.origin.test(value.origin)) {
+    if (typeof value.origin !== 'string' || !patterns.origin.test(value.origin)) {
         fail('PUBLICATION_INVALID', 'Publication reference origin is invalid.');
     }
     const origin = value.origin;
@@ -24,7 +25,7 @@ export function acceptReference(input) {
     if (identity.subject !== origin) {
         fail('PUBLICATION_INVALID', 'Publication reference subject must equal its root origin.');
     }
-    if (typeof value.revision !== 'string' || !dslSchema.patterns.revision.test(value.revision)) {
+    if (typeof value.revision !== 'string' || !patterns.revision.test(value.revision)) {
         fail('PUBLICATION_INVALID', 'Publication reference revision is invalid.');
     }
     return deepFreeze({
@@ -56,13 +57,12 @@ function acceptIssuer(input) {
         fail('PUBLICATION_INVALID', 'Publication reference issuer is invalid.');
     }
     try {
-        return auth.issuer.accept(input);
+        return acceptIssuerId(input);
     }
     catch (cause) {
-        if (cause instanceof auth.AuthValueError) {
+        if (cause instanceof AuthValueError) {
             return fail('PUBLICATION_INVALID', 'Publication reference issuer is invalid.', cause);
         }
         throw cause;
     }
 }
-//# sourceMappingURL=reference.js.map

package/dist/publication/requirements.d.ts

@@ -1,10 +1,11 @@
-import type { AuthorityOperation } from '@astrale-os/kernel-core/schema';
-import type { Key as SemanticKey, schema } from '@astrale-os/kernel-dsl/v1';
+import type { AuthorityOperation } from '@astrale-os/kernel-core/schema/authority/operation';
+import type { schema } from '@astrale-os/kernel-dsl/v1';
+import type { ClassRef, Key as SemanticKey } from '@astrale-os/kernel-dsl/v1/addressing';
 export type NonEmpty<Value> = readonly [Value, ...Value[]];
 export declare const ClassOperationOrder: readonly ["create", "read", "traverse", "update", "delete"];
 export type ClassOperation = (typeof ClassOperationOrder)[number];
 export interface ClassCapabilityRequirement {
-    readonly class: schema.ClassRef;
+    readonly class: ClassRef;
     readonly operations: NonEmpty<ClassOperation>;
 }
 export interface CapabilityAdminRequirements {
@@ -23,4 +24,3 @@ export interface PublicationRequirements {
 export declare function admitRequirements(input: unknown): PublicationRequirements;
 /** Bind explicit capability targets to exact functional dependencies in the bundle closure. */
 export declare function validateRequirements(root: schema.DomainSchema, closure: readonly schema.DomainSchema[], requirements: PublicationRequirements): void;
-//# sourceMappingURL=requirements.d.ts.map

package/dist/publication/requirements.js

@@ -1,5 +1,6 @@
-import { AuthorityOperationOrder } from '@astrale-os/kernel-core/schema';
-import { Key, Ref, schema as dslSchema } from '@astrale-os/kernel-dsl/v1';
+import { AuthorityOperationOrder } from '@astrale-os/kernel-core/schema/authority/operation';
+import { acceptDefinitionRef, callableAddress, Key } from '@astrale-os/kernel-dsl/v1/addressing';
+import { revision } from '@astrale-os/kernel-dsl/v1/schema/revision';
 import { array, deepFreeze, exact, record, unique } from './content.js';
 import { fail } from './error.js';
 export const ClassOperationOrder = Object.freeze([
@@ -46,17 +47,15 @@ export function admitRequirements(input) {
 export function validateRequirements(root, closure, requirements) {
     const dependencies = exactDependencyClosure(root, closure);
     for (const callable of requirements.capabilities.functions ?? []) {
-        validateForeignTarget(root, dependencies, callable, 'Function');
-        const dependency = dependencies.get(Key.origin(callable));
-        const reference = Key.ref(callable);
-        if (!hasCallable(dependency, reference)) {
+        const dependency = capabilityOwner(root, dependencies, callable, 'Function');
+        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);
-        validateForeignTarget(root, dependencies, key, 'Class');
-        if (dependencies.get(requirement.class.origin).classes[requirement.class.name] === undefined) {
+        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.');
         }
     }
@@ -65,9 +64,9 @@ 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 || dslSchema.revision(dependency) !== coordinate.revision) {
+            if (dependency === undefined || revision(dependency) !== coordinate.revision) {
                 fail('PUBLICATION_INVALID', 'Publication Bundle omits an exact dependency.');
             }
             if (reachable.has(dependency.origin))
@@ -83,8 +82,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;
@@ -122,16 +123,16 @@ function admitAuthorityOperations(input, kind) {
     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' ||
-        !dslSchema.patterns.origin.test(value.origin) ||
-        typeof value.name !== 'string' ||
-        !dslSchema.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 nonEmpty(input, label) {
     const values = [...array(input, 'PUBLICATION_INVALID')];
@@ -157,24 +158,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 validateForeignTarget(root, dependencies, key, label) {
+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 (!dependencies.has(origin)) {
+    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 && method.inheritance !== 'abstract';
 }
-//# sourceMappingURL=requirements.js.map

package/dist/publication/route.d.ts

@@ -1,4 +1,4 @@
-import { type Key } from '@astrale-os/kernel-dsl/v1';
+import { type Key } from '@astrale-os/kernel-dsl/v1/addressing';
 export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | '*';
 export type SingleCredentialSource = {
     readonly in: 'header';
@@ -29,5 +29,9 @@ export interface HttpRoute {
     readonly body?: RouteBody;
     readonly credential?: CredentialSource;
 }
+/** Provider-neutral build input; placement replaces path with the canonical absolute href. */
+export interface HttpRouteDeclaration extends Omit<HttpRoute, 'href'> {
+    readonly path: string;
+}
 export declare function admitRoute(input: unknown, origin: string): HttpRoute;
-//# sourceMappingURL=route.d.ts.map
+export declare function admitRouteDeclaration(input: unknown, origin: string): HttpRouteDeclaration;

package/dist/publication/route.js

@@ -1,14 +1,39 @@
-import { schema as dslSchema } from '@astrale-os/kernel-dsl/v1';
+import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
 import { admitCallableKey } from './bindings/callable.js';
 import { absoluteHttpUrl, deepFreeze, exact, record } from './content.js';
 import { fail } from './error.js';
 const ROUTE_NAME = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/u;
 export function admitRoute(input, origin) {
     const value = record(input, 'PUBLICATION_ROUTE_INVALID', 'Published HTTP route is invalid.');
+    const common = admitRouteCommon(value, origin, 'href');
+    return deepFreeze({
+        ...common,
+        href: absoluteHttpUrl(value.href, false, 'PUBLICATION_ROUTE_INVALID', true),
+    });
+}
+export function admitRouteDeclaration(input, origin) {
+    const value = record(input, 'PUBLICATION_ROUTE_INVALID', 'HTTP route declaration is invalid.');
+    const common = admitRouteCommon(value, origin, 'path');
+    if (typeof value.path !== 'string' || !value.path.startsWith('/')) {
+        fail('PUBLICATION_ROUTE_INVALID', 'Route declaration path must be relative to one issuer.');
+    }
+    let parsed;
+    try {
+        parsed = new URL(value.path, 'https://placement.invalid');
+    }
+    catch (cause) {
+        return fail('PUBLICATION_ROUTE_INVALID', 'Route declaration path is invalid.', cause);
+    }
+    if (parsed.origin !== 'https://placement.invalid' || parsed.search !== '' || parsed.hash !== '') {
+        fail('PUBLICATION_ROUTE_INVALID', 'Route declaration path cannot select an origin, query, or fragment.');
+    }
+    return deepFreeze({ ...common, path: value.path });
+}
+function admitRouteCommon(value, origin, location) {
     exact(value, [
         'name',
         'callable',
-        'href',
+        location,
         'method',
         'requestMethod',
         'default',
@@ -29,22 +54,20 @@ export function admitRoute(input, origin) {
         fail('PUBLICATION_ROUTE_INVALID', 'Route default may only be true.');
     }
     if (value.requestMethod !== undefined &&
-        (typeof value.requestMethod !== 'string' ||
-            !dslSchema.patterns.memberName.test(value.requestMethod))) {
+        (typeof value.requestMethod !== 'string' || !patterns.memberName.test(value.requestMethod))) {
         fail('PUBLICATION_ROUTE_INVALID', 'Route request-method mapping is invalid.');
     }
     if (value.receiver !== undefined &&
-        (typeof value.receiver !== 'string' || !dslSchema.patterns.memberName.test(value.receiver))) {
+        (typeof value.receiver !== 'string' || !patterns.memberName.test(value.receiver))) {
         fail('PUBLICATION_ROUTE_INVALID', 'Route receiver is invalid.');
     }
     const query = stringRecord(value.query);
     const headers = headerRecord(value.headers);
     const body = admitBody(value.body);
     const credential = admitCredential(value.credential);
-    return deepFreeze({
+    return {
         name: value.name,
         callable,
-        href: absoluteHttpUrl(value.href, false, 'PUBLICATION_ROUTE_INVALID', true),
         method: value.method,
         ...(value.requestMethod === undefined ? {} : { requestMethod: value.requestMethod }),
         ...(value.default === true ? { default: true } : {}),
@@ -53,7 +76,7 @@ export function admitRoute(input, origin) {
         ...(headers === undefined ? {} : { headers }),
         ...(body === undefined ? {} : { body }),
         ...(credential === undefined ? {} : { credential }),
-    });
+    };
 }
 function admitCredential(input) {
     if (input === undefined)
@@ -129,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 { schema as dslSchema } from '@astrale-os/kernel-dsl/v1';
-import type { BundleDescriptor } from './bundle.js';
+import type { Revision } from '@astrale-os/kernel-dsl/v1/addressing';
+import type { BundleDescriptor } from './bundle-descriptor.js';
 export interface Schema {
-    readonly revision: dslSchema.Revision;
+    readonly revision: Revision;
     readonly bundle: BundleDescriptor;
 }
 export declare function admitSchema(input: unknown): Schema;
-//# sourceMappingURL=schema.d.ts.map