@astrale-os/kernel-protocol 0.5.0-beta.45 → 0.5.0-beta.46

package/dist/publication/etag.js

@@ -1,5 +1,6 @@
 import * as portable from '@astrale-os/kernel-dsl/value';
 import { fail } from './error.js';
+import { encodeLegacyRequirements } from './legacy-requirements.js';
 const DIGEST = /^sha256:[0-9a-f]{64}$/u;
 export function admitDigest(input) {
     if (typeof input !== 'string' || !DIGEST.test(input)) {
@@ -8,7 +9,10 @@ export function admitDigest(input) {
     return input;
 }
 export function computeEtag(input) {
-    const bytes = portable.json.encode(input);
+    const wire = input.version === 2
+        ? { ...input, requirements: encodeLegacyRequirements(input.requirements) }
+        : input;
+    const bytes = portable.json.encode(wire);
     return `sha256:${sha256Hex(bytes)}`;
 }
 export function sha256Hex(input) {

package/dist/publication/index.d.ts

@@ -1,4 +1,4 @@
-export { MEDIA_TYPE, PATH, url, seal, accept, encode, type Publication } from './publication.js';
+export { MEDIA_TYPE, LEGACY_MEDIA_TYPE, mediaType, 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';
@@ -10,7 +10,7 @@ export { PublicationError, type PublicationErrorCode } from './error.js';
 export * as delivery from './delivery/index.js';
 export type { Authentication as DeliveryAuthentication, Endpoint as DeliveryEndpoint, } from './delivery-endpoint.js';
 export type { Manifest } from './manifest.js';
-export { ClassOperationOrder, admitRequirements, validateRequirements, type CapabilityAuthorityRequirements, type CapabilityProfileRequirement, type CapabilityRequirements, type ClassCapabilityRequirement, type ClassOperation, type NonEmpty, type PublicationRequirements, } from './requirements.js';
+export { ClassOperationOrder, admitRequirements, validateRequirements, type CapabilityAuthorityRequirements, type CoreCapabilityRequirement, 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, HttpRouteDeclaration, RouteBody, RouteHeaders, SingleCredentialSource, } from './route.js';
 export type { Schema } from './schema.js';

package/dist/publication/index.js

@@ -1,4 +1,4 @@
-export { MEDIA_TYPE, PATH, url, seal, accept, encode } from './publication.js';
+export { MEDIA_TYPE, LEGACY_MEDIA_TYPE, mediaType, 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';

package/dist/publication/legacy-requirements.d.ts

@@ -0,0 +1,12 @@
+import type { PublicationRequirements } from './requirements.js';
+/** Read the retired v2 wire coordinate without exposing it in canonical requirements. */
+export declare function decodeLegacyRequirements(input: unknown): PublicationRequirements;
+/** Preserve immutable v2 bytes and the historical installation-target digest vocabulary. */
+export declare function encodeLegacyRequirements(input: PublicationRequirements): Readonly<{
+    capabilities: Readonly<{
+        functions?: import("./requirements.js").NonEmpty<import("@astrale-os/kernel-dsl/v1").Key.Callable>;
+        classes?: import("./requirements.js").NonEmpty<import("./requirements.js").ClassCapabilityRequirement>;
+        authority?: import("./requirements.js").CapabilityAuthorityRequirements;
+        profiles?: import("./requirements.js").NonEmpty<import("./requirements.js").CoreCapabilityRequirement> | undefined;
+    }>;
+}>;

package/dist/publication/legacy-requirements.js

@@ -0,0 +1,23 @@
+import { exact, record } from './content.js';
+import { admitRequirements } from './requirements.js';
+/** Read the retired v2 wire coordinate without exposing it in canonical requirements. */
+export function decodeLegacyRequirements(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, ['authority', 'classes', 'functions', 'profiles'], 'PUBLICATION_INVALID');
+    const { profiles, ...principal } = capabilities;
+    return admitRequirements({
+        capabilities: { ...principal, ...(profiles === undefined ? {} : { core: profiles }) },
+    });
+}
+/** Preserve immutable v2 bytes and the historical installation-target digest vocabulary. */
+export function encodeLegacyRequirements(input) {
+    const { core, ...principal } = input.capabilities;
+    return Object.freeze({
+        capabilities: Object.freeze({
+            ...principal,
+            ...(core === undefined ? {} : { profiles: core }),
+        }),
+    });
+}

package/dist/publication/publication.d.ts

@@ -9,12 +9,14 @@ import type { PublicationRequirements } from './requirements.js';
 import type { HttpRoute } from './route.js';
 import type { Schema } from './schema.js';
 export declare const PATH: '/.well-known/astrale/domain.json';
-export declare const MEDIA_TYPE: 'application/vnd.astrale.domain-publication+json;v=2';
+export declare const MEDIA_TYPE: 'application/vnd.astrale.domain-publication+json;v=3';
+export declare const LEGACY_MEDIA_TYPE: 'application/vnd.astrale.domain-publication+json;v=2';
+export declare function mediaType(input: Pick<Publication, 'version'>): typeof MEDIA_TYPE | typeof LEGACY_MEDIA_TYPE;
 /** Resolve the canonical Publication URL beneath one exact HTTP(S) serving issuer. */
 export declare function url(input: string): string;
 export interface Publication {
     readonly format: 'astrale.domain.publication';
-    readonly version: 2;
+    readonly version: 2 | 3;
     readonly origin: Key.Origin;
     readonly identity: {
         readonly issuer: IssuerId;

package/dist/publication/publication.js

@@ -8,12 +8,17 @@ 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 { decodeLegacyRequirements, encodeLegacyRequirements } from './legacy-requirements.js';
 import { admitManifest } from './manifest.js';
 import { admitRequirements } from './requirements.js';
 import { admitRoute } from './route.js';
 import { admitSchema } from './schema.js';
 export const PATH = '/.well-known/astrale/domain.json';
-export const MEDIA_TYPE = 'application/vnd.astrale.domain-publication+json;v=2';
+export const MEDIA_TYPE = 'application/vnd.astrale.domain-publication+json;v=3';
+export const LEGACY_MEDIA_TYPE = 'application/vnd.astrale.domain-publication+json;v=2';
+export function mediaType(input) {
+    return input.version === 2 ? LEGACY_MEDIA_TYPE : MEDIA_TYPE;
+}
 /** Resolve the canonical Publication URL beneath one exact HTTP(S) serving issuer. */
 export function url(input) {
     const admitted = admitIssuer(input);
@@ -34,20 +39,23 @@ export function url(input) {
     return `${admitted.replace(/\/+$/u, '')}${PATH}`;
 }
 export function seal(input) {
-    const canonical = withoutEtag(acceptPublication({ ...input, etag: 'canonicalizing' }, false, true));
-    return acceptPublication({ ...canonical, etag: computeEtag(canonical) }, false);
+    const canonical = withoutEtag(acceptPublication({ ...input, etag: 'canonicalizing' }, 'seal'));
+    return acceptPublication({ ...canonical, etag: computeEtag(canonical) }, 'canonical');
 }
 export function accept(input) {
-    const publication = acceptPublication(input, true);
+    const publication = acceptPublication(input, 'wire');
     if (publication.etag !== computeEtag(withoutEtag(publication))) {
         fail('PUBLICATION_ETAG_MISMATCH', 'Publication ETag does not match its canonical content.');
     }
     return publication;
 }
 export function encode(input) {
-    return portable.json.encode(input);
+    const wire = input.version === 2
+        ? { ...input, requirements: encodeLegacyRequirements(input.requirements) }
+        : input;
+    return portable.json.encode(wire);
 }
-function acceptPublication(input, requireEtag, canonicalizeViews = false) {
+function acceptPublication(input, mode) {
     const value = record(input, 'PUBLICATION_INVALID', 'Expected a Publication object.');
     exact(value, [
         'format',
@@ -62,7 +70,8 @@ function acceptPublication(input, requireEtag, canonicalizeViews = false) {
         'routes',
         'delivery',
     ], 'PUBLICATION_INVALID');
-    if (value.format !== 'astrale.domain.publication' || value.version !== 2) {
+    if (value.format !== 'astrale.domain.publication' ||
+        (value.version !== 2 && value.version !== 3)) {
         fail('PUBLICATION_INVALID', 'Unsupported Publication format or version.');
     }
     if (typeof value.origin !== 'string' || !patterns.origin.test(value.origin)) {
@@ -76,13 +85,15 @@ function acceptPublication(input, requireEtag, canonicalizeViews = false) {
         fail('PUBLICATION_INVALID', 'Publication identity subject must equal its root origin.');
     }
     const publishedSchema = admitSchema(value.schema);
-    const requirements = admitRequirements(value.requirements);
+    const requirements = value.version === 2 && mode === 'wire'
+        ? decodeLegacyRequirements(value.requirements)
+        : admitRequirements(value.requirements);
     const manifest = admitManifest(value.manifest);
     const bindingSet = record(value.bindings, 'PUBLICATION_BINDING_INVALID', 'Publication bindings are invalid.');
     exact(bindingSet, ['callables', 'views'], 'PUBLICATION_BINDING_INVALID');
     const callables = array(bindingSet.callables, 'PUBLICATION_BINDING_INVALID').map((entry) => admitCallableBinding(entry, origin));
     unique(callables.map(({ callable }) => callable), 'PUBLICATION_BINDING_INVALID', 'callable binding');
-    const views = array(bindingSet.views, 'PUBLICATION_VIEW_INVALID').map((entry) => canonicalizeViews ? canonicalizeViewBinding(entry, origin) : admitViewBinding(entry, origin));
+    const views = array(bindingSet.views, 'PUBLICATION_VIEW_INVALID').map((entry) => mode === 'seal' ? canonicalizeViewBinding(entry, origin) : admitViewBinding(entry, origin));
     unique(views.map(({ view }) => view), 'PUBLICATION_VIEW_INVALID', 'View binding');
     const routes = array(value.routes, 'PUBLICATION_ROUTE_INVALID').map((entry) => admitRoute(entry, origin));
     unique(routes.map(({ name }) => name), 'PUBLICATION_ROUTE_INVALID', 'route name');
@@ -101,12 +112,12 @@ function acceptPublication(input, requireEtag, canonicalizeViews = false) {
         }
     }
     const delivery = admitDeliveryEndpoint(value.delivery, publishedSchema.bundle.href);
-    const admittedEtag = requireEtag ? admitDigest(value.etag) : value.etag;
+    const admittedEtag = mode === 'wire' ? admitDigest(value.etag) : value.etag;
     if (typeof admittedEtag !== 'string')
         fail('PUBLICATION_INVALID', 'Publication ETag is missing.');
     return deepFreeze({
         format: 'astrale.domain.publication',
-        version: 2,
+        version: value.version,
         origin,
         identity: { issuer, subject: origin },
         etag: admittedEtag,

package/dist/publication/requirements.d.ts

@@ -16,10 +16,10 @@ export interface CapabilityRequirements {
     readonly functions?: NonEmpty<SemanticKey.Callable>;
     readonly classes?: NonEmpty<ClassCapabilityRequirement>;
     readonly authority?: CapabilityAuthorityRequirements;
-    readonly profiles?: NonEmpty<CapabilityProfileRequirement>;
+    readonly core?: NonEmpty<CoreCapabilityRequirement>;
 }
 /** Installation-owned authority materialized onto one local Core Identity. */
-export interface CapabilityProfileRequirement {
+export interface CoreCapabilityRequirement {
     readonly subject: CoreRef;
     readonly functions?: NonEmpty<SemanticKey.Callable>;
     readonly classes?: NonEmpty<ClassCapabilityRequirement>;
@@ -28,7 +28,7 @@ export interface CapabilityProfileRequirement {
 export interface PublicationRequirements {
     readonly capabilities: CapabilityRequirements;
 }
-/** Admit the exact closed Publication v2 requirements object. */
+/** Admit the exact closed canonical requirements object used by Publication v3. */
 export declare function admitRequirements(input: unknown): PublicationRequirements;
 /** Bind explicit capability targets to exact functional dependencies in the bundle closure. */
 export declare function validateRequirements(root: schemaLanguage.DomainSchema, closure: readonly schemaLanguage.DomainSchema[], requirements: PublicationRequirements): void;

package/dist/publication/requirements.js

@@ -15,12 +15,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, ['authority', 'classes', 'functions', 'profiles'], 'PUBLICATION_INVALID');
+    exact(capabilities, ['authority', 'classes', 'functions', 'core'], 'PUBLICATION_INVALID');
     const functions = capabilities.functions === undefined
         ? undefined
         : nonEmpty(capabilities.functions, 'Function capability requirements').map(admitCallable);
@@ -38,12 +38,12 @@ export function admitRequirements(input) {
     const authority = capabilities.authority === undefined
         ? undefined
         : admitAuthorityRequirements(capabilities.authority);
-    const profiles = capabilities.profiles === undefined
+    const core = capabilities.core === undefined
         ? undefined
-        : nonEmpty(capabilities.profiles, 'Capability profiles').map(admitCapabilityProfile);
-    if (profiles !== undefined) {
-        unique(profiles.map(({ subject }) => Key.of(subject)), 'PUBLICATION_INVALID', 'Capability profile subject');
-        canonical(profiles, (left, right) => compare(Key.of(left.subject), Key.of(right.subject)), 'Capability profiles');
+        : 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: {
@@ -54,33 +54,35 @@ export function admitRequirements(input) {
                 ? {}
                 : { classes: Object.freeze(classes) }),
             ...(authority === undefined ? {} : { authority }),
-            ...(profiles === undefined
+            ...(core === undefined
                 ? {}
-                : { profiles: Object.freeze(profiles) }),
+                : { core: Object.freeze(core) }),
         },
     });
 }
-function admitCapabilityProfile(input) {
-    const profile = record(input, 'PUBLICATION_INVALID', 'Capability profile requirement is invalid.');
-    exact(profile, ['authority', 'classes', 'functions', 'subject'], 'PUBLICATION_INVALID');
-    const subject = admitCoreRef(profile.subject);
-    const functions = profile.functions === undefined
+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(profile.functions, 'Capability profile Function requirements').map(admitCallable);
+        : nonEmpty(requirement.functions, 'Core capability Function requirements').map(admitCallable);
     if (functions !== undefined) {
-        unique(functions, 'PUBLICATION_INVALID', 'Capability profile Function requirement');
-        canonical(functions, compare, 'Capability profile Function requirements');
+        unique(functions, 'PUBLICATION_INVALID', 'Core capability Function requirement');
+        canonical(functions, compare, 'Core capability Function requirements');
     }
-    const classes = profile.classes === undefined
+    const classes = requirement.classes === undefined
         ? undefined
-        : nonEmpty(profile.classes, 'Capability profile Class requirements').map(admitClassRequirement);
+        : nonEmpty(requirement.classes, 'Core capability Class requirements').map(admitClassRequirement);
     if (classes !== undefined) {
-        unique(classes.map((entry) => classKey(entry.class)), 'PUBLICATION_INVALID', 'Capability profile Class requirement');
-        canonical(classes, (left, right) => compare(classKey(left.class), classKey(right.class)), 'Capability profile Class requirements');
+        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 = profile.authority === undefined ? undefined : admitAuthorityRequirements(profile.authority);
+    const authority = requirement.authority === undefined
+        ? undefined
+        : admitAuthorityRequirements(requirement.authority);
     if (functions === undefined && classes === undefined && authority === undefined) {
-        fail('PUBLICATION_INVALID', 'Capability profile requirements cannot be empty.');
+        fail('PUBLICATION_INVALID', 'Core capability requirements cannot be empty.');
     }
     return Object.freeze({
         subject,
@@ -109,26 +111,26 @@ export function validateRequirements(root, closure, requirements) {
             fail('PUBLICATION_INVALID', 'Class capability requirement names an unknown dependency Class.');
         }
     }
-    for (const profile of requirements.capabilities.profiles ?? []) {
-        const subject = root.core.nodes[profile.subject.name];
-        if (profile.subject.origin !== root.origin ||
+    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', 'Capability profile subject must name one local Core Identity.');
+            fail('PUBLICATION_INVALID', 'Core capability subject must name one local Core Identity.');
         }
-        for (const callable of profile.functions ?? []) {
+        for (const callable of requirement.functions ?? []) {
             const dependency = capabilityOwner(root, dependencies, callable, 'Function');
             if (!hasCallable(dependency, callable)) {
-                fail('PUBLICATION_INVALID', 'Capability profile Function requirement names an unknown dependency callable.');
+                fail('PUBLICATION_INVALID', 'Core capability Function requirement names an unknown dependency callable.');
             }
         }
-        for (const requirement of profile.classes ?? []) {
-            const key = Key.of(requirement.class);
-            const owner = requirement.class.origin === root.origin
+        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[requirement.class.name] === undefined) {
-                fail('PUBLICATION_INVALID', 'Capability profile Class requirement names an unknown dependency Class.');
+            if (owner.classes[classRequirement.class.name] === undefined) {
+                fail('PUBLICATION_INVALID', 'Core capability Class requirement names an unknown dependency Class.');
             }
         }
     }
@@ -229,10 +231,10 @@ function admitCoreRef(input) {
         value = acceptDefinitionRef(input);
     }
     catch {
-        fail('PUBLICATION_INVALID', 'Capability profile subject is invalid.');
+        fail('PUBLICATION_INVALID', 'Core capability subject is invalid.');
     }
     if (value.kind !== 'core') {
-        fail('PUBLICATION_INVALID', 'Capability profile subject must be one local Core reference.');
+        fail('PUBLICATION_INVALID', 'Core capability subject must be one local Core reference.');
     }
     return value;
 }

package/dist/runtime/artifact.d.ts

@@ -31,13 +31,15 @@ export interface Module {
 /** Immutable portable closure selected by one local Schema installation source. */
 export interface RuntimeArtifact {
     readonly format: 'astrale.domain-runtime-artifact';
-    readonly version: 2;
+    readonly version: 2 | 3;
     readonly issuer: IssuerId;
     readonly bundle: Ref;
     readonly requirements: PublicationRequirements;
     readonly modules: readonly [Module, ...Module[]];
 }
-export declare const MEDIA_TYPE: 'application/vnd.astrale.domain-runtime+json;v=2';
+export declare const MEDIA_TYPE: 'application/vnd.astrale.domain-runtime+json;v=3';
+export declare const LEGACY_MEDIA_TYPE: 'application/vnd.astrale.domain-runtime+json;v=2';
+export declare function mediaType(input: Pick<RuntimeArtifact, 'version'>): typeof MEDIA_TYPE | typeof LEGACY_MEDIA_TYPE;
 export declare function accept(input: unknown): RuntimeArtifact;
 export declare function encode(input: RuntimeArtifact): Uint8Array;
 export declare function runtimeDigest(input: RuntimeArtifact): Digest;

package/dist/runtime/artifact.js

@@ -4,18 +4,26 @@ import * as portable from '@astrale-os/kernel-dsl/value';
 import { sha256 } from '@noble/hashes/sha2.js';
 import * as artifact from '../artifact/index.js';
 import { admitRequirements } from '../publication/index.js';
-export const MEDIA_TYPE = 'application/vnd.astrale.domain-runtime+json;v=2';
+import { decodeLegacyRequirements, encodeLegacyRequirements, } from '../publication/legacy-requirements.js';
+export const MEDIA_TYPE = 'application/vnd.astrale.domain-runtime+json;v=3';
+export const LEGACY_MEDIA_TYPE = 'application/vnd.astrale.domain-runtime+json;v=2';
+export function mediaType(input) {
+    return input.version === 2 ? LEGACY_MEDIA_TYPE : MEDIA_TYPE;
+}
 export function accept(input) {
     const root = record(input, 'Domain Runtime artifact');
     exact(root, ['bundle', 'format', 'issuer', 'modules', 'requirements', 'version']);
-    if (root.format !== 'astrale.domain-runtime-artifact' || root.version !== 2) {
+    if (root.format !== 'astrale.domain-runtime-artifact' ||
+        (root.version !== 2 && root.version !== 3)) {
         invalid('Domain Runtime artifact format or version is unsupported.');
     }
     if (typeof root.issuer !== 'string')
         invalid('Domain Runtime artifact issuer is invalid.');
     const admittedIssuer = acceptIssuer(root.issuer);
     const bundle = artifact.accept(root.bundle);
-    const requirements = admitRequirements(root.requirements);
+    const requirements = root.version === 2
+        ? decodeLegacyRequirements(root.requirements)
+        : admitRequirements(root.requirements);
     if (!Array.isArray(root.modules) || root.modules.length === 0) {
         invalid('Domain Runtime artifact requires at least one Module.');
     }
@@ -26,7 +34,7 @@ export function accept(input) {
     }
     return Object.freeze({
         format: 'astrale.domain-runtime-artifact',
-        version: 2,
+        version: root.version,
         issuer: admittedIssuer,
         bundle,
         requirements,
@@ -34,10 +42,15 @@ export function accept(input) {
     });
 }
 export function encode(input) {
-    return portable.json.encode(accept(input));
+    return portable.json.encode(wire(accept(wire(input))));
 }
 export function runtimeDigest(input) {
-    return digestBytes(portable.json.encode(input));
+    return digestBytes(portable.json.encode(wire(input)));
+}
+function wire(input) {
+    return input.version === 2
+        ? { ...input, requirements: encodeLegacyRequirements(input.requirements) }
+        : input;
 }
 export function acceptExecutable(input) {
     return executable(input, 0);

package/dist/runtime/index.d.ts

@@ -1 +1 @@
-export { MEDIA_TYPE, accept, acceptExecutable, encode, executableClosure, executableDigest, runtimeDigest, type Digest, type Executable, type ExecutableDependency, type Export, type Module, type RuntimeArtifact, type Ref, } from './artifact.js';
+export { MEDIA_TYPE, LEGACY_MEDIA_TYPE, mediaType, accept, acceptExecutable, encode, executableClosure, executableDigest, runtimeDigest, type Digest, type Executable, type ExecutableDependency, type Export, type Module, type RuntimeArtifact, type Ref, } from './artifact.js';

package/dist/runtime/index.js

@@ -1 +1 @@
-export { MEDIA_TYPE, accept, acceptExecutable, encode, executableClosure, executableDigest, runtimeDigest, } from './artifact.js';
+export { MEDIA_TYPE, LEGACY_MEDIA_TYPE, mediaType, accept, acceptExecutable, encode, executableClosure, executableDigest, runtimeDigest, } from './artifact.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-protocol",
-  "version": "0.5.0-beta.45",
+  "version": "0.5.0-beta.46",
   "description": "Portable Astrale invocation, publication, installation, routing, and issuer protocols",
   "license": "Apache-2.0",
   "repository": {
@@ -75,6 +75,10 @@
       "types": "./dist/publication/requirements.d.ts",
       "import": "./dist/publication/requirements.js"
     },
+    "./publication/legacy-requirements": {
+      "types": "./dist/publication/legacy-requirements.d.ts",
+      "import": "./dist/publication/legacy-requirements.js"
+    },
     "./publication/delivery": {
       "types": "./dist/publication/delivery/index.d.ts",
       "import": "./dist/publication/delivery/index.js"