@astrale-os/kernel-protocol 0.5.0-beta.6 → 0.5.0-beta.61

package/dist/schema/installation/introspection/codec.js

@@ -1,24 +1,38 @@
-import { bundle } from '@astrale-os/kernel-dsl/v1';
-import * as artifact from '../../../artifact/index.js';
-import { json } from '../../../codecs/index.js';
+import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
+import * as bundle from '@astrale-os/kernel-dsl/v1/bundle/transport';
+import { revision as schemaRevision } from '@astrale-os/kernel-dsl/v1/schema/revision';
+import { admitCallableBinding, admitViewBinding } from '../../../publication/bindings/index.js';
 import * as publication from '../../../publication/index.js';
-import * as runtime from '../../../runtime/index.js';
-export const MEDIA_TYPE = 'application/vnd.astrale.schema-introspection.v1+msgpack';
+export const MEDIA_TYPE = 'application/vnd.astrale.schema-introspection.v2+msgpack';
+const encodedBundles = new WeakMap();
+const admittedBundles = new Map();
+const MAXIMUM_ADMITTED_BUNDLES = 128;
 export async function encode(input, result) {
-    const fields = selected(input);
-    const wire = result === null ? null : encodeResult(fields, result);
+    const request = admitRequest(input);
+    const wire = request.kind === 'bundle'
+        ? encodeDomainBundle(result)
+        : request.kind === 'dependencies'
+            ? encodeDomainDependencies(result)
+            : encodeDomainInfo(result);
+    proveRequestedOrigin(request, result);
+    // Non-literal specifiers keep msgpackr's Node-typed declarations out of consumers (see codecs/msgpack.ts).
     const { pack } = await import('msgpackr/pack');
     return new Uint8Array(pack(wire));
 }
 export async function decode(input, bytes, limits) {
+    const request = admitRequest(input);
     if (!(bytes instanceof Uint8Array))
         invalid('Schema introspection evidence must be binary.');
     admitLimit(limits.maximumPublicationBytes, 'Publication');
-    admitLimit(limits.maximumBundleBytes, 'Bundle');
-    if (bytes.byteLength > limits.maximumPublicationBytes + limits.maximumBundleBytes + 2_048) {
+    if (request.kind === 'bundle')
+        admitLimit(limits.maximumBundleBytes, 'Bundle');
+    const maximumEvidenceBytes = limits.maximumPublicationBytes +
+        (request.kind === 'bundle' ? limits.maximumBundleBytes : 0) +
+        4_096;
+    if (bytes.byteLength > maximumEvidenceBytes) {
         invalid('Schema introspection evidence exceeds its declared bounds.');
     }
-    const { unpack } = await import('msgpackr/unpack');
+    const { unpack } = await import('msgpackr');
     let decoded;
     try {
         decoded = unpack(bytes);
@@ -26,202 +40,196 @@ export async function decode(input, bytes, limits) {
     catch (cause) {
         throw new TypeError('Schema introspection evidence is malformed.', { cause });
     }
-    if (decoded === null)
-        return null;
-    if (!isRecord(decoded))
-        invalid('Schema introspection result must be an object or null.');
-    const fields = selected(input);
-    exact(decoded, fields, 'Schema introspection result');
-    return decodeResult(fields, decoded, limits);
+    const result = (request.kind === 'bundle'
+        ? decodeDomainBundle(decoded, limits.maximumBundleBytes)
+        : request.kind === 'dependencies'
+            ? acceptDomainDependencies(decoded)
+            : acceptDomainInfo(decoded));
+    proveRequestedOrigin(request, result);
+    return result;
 }
-function encodeResult(fields, result) {
-    exact(result, fields, 'Schema introspection result');
-    const source = fields.includes('source') ? encodeSource(result.source) : undefined;
-    const output = {};
-    for (const field of fields) {
-        switch (field) {
-            case 'state':
-                output.state = state(result.state);
-                break;
-            case 'target':
-                output.target = digest(result.target, 'Installation target');
-                break;
-            case 'source':
-                output.source = source;
-                break;
-            case 'bundle':
-                output.bundle = encodeBundle(result.bundle, result.source);
-                break;
-            case 'readiness':
-                output.readiness =
-                    result.readiness === null ? null : digest(result.readiness, 'Installation readiness');
-                break;
-            case 'capabilities':
-                output.capabilities = capabilities(result.capabilities);
-                break;
-        }
-    }
-    return Object.freeze(output);
+function proveRequestedOrigin(request, result) {
+    const origin = request.kind === 'inspect'
+        ? result.origin
+        : result.domain.origin;
+    if (origin !== request.origin)
+        invalid('Schema introspection evidence does not match the requested origin.');
+}
+function encodeDomainDependencies(input) {
+    const admitted = acceptDomainDependencies(input);
+    return Object.freeze({
+        domain: encodeDomainInfo(admitted.domain),
+        dependencies: admitted.dependencies.map((binding) => ({ ...binding })),
+    });
 }
-function decodeResult(fields, input, limits) {
-    const source = fields.includes('source') ? decodeSource(input.source, limits) : undefined;
-    const output = {};
-    for (const field of fields) {
-        switch (field) {
-            case 'state':
-                output.state = state(input.state);
-                break;
-            case 'target':
-                output.target = digest(input.target, 'Installation target');
-                break;
-            case 'source':
-                output.source = source;
-                break;
-            case 'bundle':
-                output.bundle = decodeBundle(input.bundle, source, limits.maximumBundleBytes);
-                break;
-            case 'readiness':
-                output.readiness =
-                    input.readiness === null ? null : digest(input.readiness, 'Installation readiness');
-                break;
-            case 'capabilities':
-                output.capabilities = capabilities(input.capabilities);
-                break;
+/** Admit dependency bindings: origin-ordered, one per origin, each label agreeing with its revisions. */
+export function acceptDomainDependencies(input) {
+    const value = record(input, 'Domain dependencies result');
+    exact(value, ['dependencies', 'domain'], 'Domain dependencies result');
+    const domain = acceptDomainInfo(value.domain);
+    if (!Array.isArray(value.dependencies))
+        invalid('Domain dependency bindings are invalid.');
+    const dependencies = value.dependencies.map(acceptDependencyBinding);
+    for (const [index, binding] of dependencies.entries()) {
+        const previous = dependencies[index - 1];
+        if (previous !== undefined && previous.origin >= binding.origin) {
+            invalid('Domain dependency bindings must be origin-ordered and unique.');
         }
+        if (binding.origin === domain.origin)
+            invalid('Domain dependency bindings cannot name the Domain.');
     }
-    if (output.state === 'ready' && Object.hasOwn(output, 'readiness') && output.readiness === null) {
-        invalid('A ready Installation requires readiness evidence.');
-    }
-    return Object.freeze(output);
+    return Object.freeze({ domain, dependencies: Object.freeze(dependencies) });
 }
-function encodeSource(input) {
-    if (input?.kind === 'builtin') {
-        return Object.freeze({
-            kind: 'builtin',
-            bundle: ref(input.bundle, publication.BUNDLE_MEDIA_TYPE, 'Builtin schema Bundle'),
-        });
+function acceptDependencyBinding(input) {
+    const value = record(input, 'Domain dependency binding');
+    exact(value, ['active', 'binding', 'origin', 'pinned'], 'Domain dependency binding');
+    if (typeof value.origin !== 'string' || !patterns.origin.test(value.origin)) {
+        invalid('Domain dependency binding origin is invalid.');
     }
-    if (input?.kind === 'local') {
-        return Object.freeze({
-            kind: 'local',
-            artifact: ref(input.artifact, runtime.MEDIA_TYPE, 'Local Runtime Artifact'),
-            bundle: ref(input.bundle, publication.BUNDLE_MEDIA_TYPE, 'Local schema Bundle'),
-        });
+    if (typeof value.pinned !== 'string' || !patterns.revision.test(value.pinned)) {
+        invalid('Domain dependency binding pinned revision is invalid.');
     }
-    if (input?.kind === 'remote') {
-        return Object.freeze({
-            kind: 'remote',
-            publication: publication.encode(publication.accept(input.publication)),
-        });
+    if (typeof value.active !== 'string' || !patterns.revision.test(value.active)) {
+        invalid('Domain dependency binding active revision is invalid.');
     }
-    return invalid('Installation source is invalid.');
+    const expected = value.pinned === value.active ? 'exact' : 'retained';
+    if (value.binding !== expected)
+        invalid('Domain dependency binding label is invalid.');
+    return Object.freeze({
+        origin: value.origin,
+        pinned: value.pinned,
+        active: value.active,
+        binding: expected,
+    });
 }
-function decodeSource(input, limits) {
-    if (!isRecord(input))
-        invalid('Installation source is invalid.');
-    if (input.kind === 'builtin') {
-        exact(input, ['bundle', 'kind'], 'Builtin installation source');
-        return Object.freeze({
-            kind: 'builtin',
-            bundle: ref(input.bundle, publication.BUNDLE_MEDIA_TYPE, 'Builtin schema Bundle'),
-        });
+function encodeDomainBundle(input) {
+    exact(input, ['bundle', 'domain'], 'Domain Bundle result');
+    const admittedDomain = acceptDomainInfo(input.domain);
+    const domain = encodeDomainInfo(admittedDomain);
+    proveBundle(input.bundle, admittedDomain);
+    const encoded = encodedBundles.get(input.bundle) ?? bundle.encode(input.bundle);
+    if (!encodedBundles.has(input.bundle))
+        encodedBundles.set(input.bundle, encoded);
+    return Object.freeze({ domain, bundle: encoded });
+}
+function decodeDomainBundle(input, maximum) {
+    const value = record(input, 'Domain Bundle result');
+    exact(value, ['bundle', 'domain'], 'Domain Bundle result');
+    const domain = acceptDomainInfo(value.domain);
+    const encoded = boundedBytes(value.bundle, maximum, 'Bundle');
+    const cached = admittedBundles.get(domain.generation);
+    if (cached !== undefined && sameBytes(cached.bytes, encoded)) {
+        return Object.freeze({ domain, bundle: cached.bundle });
     }
-    if (input.kind === 'local') {
-        exact(input, ['artifact', 'bundle', 'kind'], 'Local installation source');
-        return Object.freeze({
-            kind: 'local',
-            artifact: ref(input.artifact, runtime.MEDIA_TYPE, 'Local Runtime Artifact'),
-            bundle: ref(input.bundle, publication.BUNDLE_MEDIA_TYPE, 'Local schema Bundle'),
-        });
+    let admitted;
+    try {
+        admitted = bundle.decode(encoded);
     }
-    if (input.kind === 'remote') {
-        exact(input, ['kind', 'publication'], 'Remote installation source');
-        const encoded = boundedBytes(input.publication, limits.maximumPublicationBytes, 'Publication');
-        let admitted;
-        try {
-            admitted = publication.accept(json.decode(encoded));
-        }
-        catch (cause) {
-            throw new TypeError('Remote installed Publication is invalid.', { cause });
-        }
-        if (!equal(encoded, publication.encode(admitted))) {
-            invalid('Remote installed Publication is not canonical.');
-        }
-        return Object.freeze({ kind: 'remote', publication: admitted });
+    catch (cause) {
+        throw new TypeError('Installed Domain Bundle is invalid.', { cause });
+    }
+    proveBundle(admitted, domain);
+    admittedBundles.delete(domain.generation);
+    admittedBundles.set(domain.generation, Object.freeze({ bytes: encoded, bundle: admitted }));
+    if (admittedBundles.size > MAXIMUM_ADMITTED_BUNDLES) {
+        admittedBundles.delete(admittedBundles.keys().next().value);
+    }
+    return Object.freeze({ domain, bundle: admitted });
+}
+function sameBytes(left, right) {
+    if (left.byteLength !== right.byteLength)
+        return false;
+    for (let index = 0; index < left.byteLength; index += 1) {
+        if (left[index] !== right[index])
+            return false;
     }
-    return invalid('Installation source kind is invalid.');
+    return true;
 }
-function encodeBundle(input, source) {
-    if (source === undefined || input === undefined)
-        invalid('Bundle source evidence is missing.');
-    const admitted = source.kind === 'remote'
-        ? publication.acceptBundle(source.publication, input)
-        : bundle.accept(input);
-    const encoded = bundle.encode(admitted);
-    if (source.kind !== 'remote' &&
-        !same(artifact.identify(encoded, publication.BUNDLE_MEDIA_TYPE), source.bundle)) {
-        invalid('Local schema Bundle does not match its source Ref.');
+function encodeDomainInfo(input) {
+    return acceptDomainInfo(input);
+}
+export function acceptDomainInfo(input) {
+    const value = record(input, 'Domain info');
+    exact(value, ['bindings', 'capabilities', 'generation', 'origin', 'publication', 'readiness', 'revision'], 'Domain info');
+    if (typeof value.origin !== 'string' || !patterns.origin.test(value.origin)) {
+        invalid('Domain info origin is invalid.');
+    }
+    if (typeof value.revision !== 'string' || !patterns.revision.test(value.revision)) {
+        invalid('Domain info revision is invalid.');
     }
-    return encoded;
+    const origin = value.origin;
+    const revision = value.revision;
+    const published = publicationReference(value.publication, origin, revision);
+    return Object.freeze({
+        origin,
+        revision,
+        generation: digest(value.generation, 'Domain generation'),
+        publication: published,
+        readiness: digest(value.readiness, 'Domain readiness'),
+        capabilities: capabilities(value.capabilities),
+        bindings: bindings(value.bindings, origin),
+    });
 }
-function decodeBundle(input, source, maximum) {
-    const encoded = boundedBytes(input, maximum, 'Bundle');
+function publicationReference(input, origin, revision) {
+    if (input === null)
+        return null;
     let admitted;
     try {
-        admitted =
-            source.kind === 'remote'
-                ? publication.decodeBundle(source.publication, encoded)
-                : bundle.decode(encoded);
+        admitted = publication.acceptReference(input);
     }
     catch (cause) {
-        throw new TypeError('Installed schema Bundle is invalid.', { cause });
+        throw new TypeError('Domain Publication metadata is invalid.', { cause });
     }
-    if (!equal(encoded, bundle.encode(admitted)))
-        invalid('Installed schema Bundle is not canonical.');
-    if (source.kind !== 'remote' &&
-        !same(artifact.identify(encoded, publication.BUNDLE_MEDIA_TYPE), source.bundle)) {
-        invalid('Local schema Bundle does not match its source Ref.');
+    if (admitted.origin !== origin || admitted.revision !== revision) {
+        invalid('Domain Publication metadata does not match its Schema coordinate.');
     }
     return admitted;
 }
-function selected(input) {
-    if (input === null ||
-        typeof input !== 'object' ||
-        input.from?.kind !== 'installation' ||
-        input.select === null ||
-        typeof input.select !== 'object') {
-        invalid('Schema introspection request is invalid.');
+function bindings(input, origin) {
+    const value = record(input, 'Domain bindings');
+    exact(value, ['callables', 'views'], 'Domain bindings');
+    if (!Array.isArray(value.callables) || !Array.isArray(value.views)) {
+        invalid('Domain bindings are invalid.');
     }
-    const allowed = ['state', 'target', 'source', 'bundle', 'readiness', 'capabilities'];
-    const fields = Object.keys(input.select);
-    if (fields.length === 0 ||
-        fields.some((field) => !allowed.includes(field) ||
-            input.select[field] !== true) ||
-        (input.select.bundle === true && input.select.source !== true)) {
-        invalid('Schema introspection selection is invalid.');
+    try {
+        return Object.freeze({
+            callables: Object.freeze(value.callables.map((entry) => admitCallableBinding(entry, origin))),
+            views: Object.freeze(value.views.map((entry) => admitViewBinding(entry, origin))),
+        });
+    }
+    catch (cause) {
+        throw new TypeError('Domain bindings are invalid.', { cause });
+    }
+}
+function proveBundle(input, domain) {
+    if (input.root.origin !== domain.origin || schemaRevision(input.root) !== domain.revision) {
+        invalid('Installed Bundle root does not match the ready Domain coordinate.');
     }
-    return Object.freeze(allowed.filter((field) => input.select[field] === true));
 }
 function capabilities(input) {
-    if (!isRecord(input))
-        invalid('Installation capabilities are invalid.');
-    exact(input, ['materialized', 'requested'], 'Installation capabilities');
+    const value = record(input, 'Domain capabilities');
+    exact(value, ['materialized', 'requested'], 'Domain capabilities');
     try {
-        const requested = publication.admitRequirements({ capabilities: input.requested }).capabilities;
+        const requested = publication.admitRequirements({ capabilities: value.requested }).capabilities;
         const materialized = publication.admitRequirements({
-            capabilities: input.materialized,
+            capabilities: value.materialized,
         }).capabilities;
         return Object.freeze({ requested, materialized });
     }
     catch (cause) {
-        throw new TypeError('Installation capabilities are invalid.', { cause });
+        throw new TypeError('Domain capabilities are invalid.', { cause });
     }
 }
-function state(input) {
-    if (input !== 'installed' && input !== 'ready' && input !== 'removing') {
-        invalid('Installation state is invalid.');
+function admitRequest(input) {
+    const value = record(input, 'Schema introspection request');
+    exact(value, ['kind', 'origin'], 'Schema introspection request');
+    if (value.kind !== 'inspect' && value.kind !== 'bundle' && value.kind !== 'dependencies') {
+        invalid('Schema introspection kind is invalid.');
     }
-    return input;
+    if (typeof value.origin !== 'string' || !patterns.origin.test(value.origin)) {
+        invalid('Schema introspection origin is invalid.');
+    }
+    return Object.freeze({ kind: value.kind, origin: value.origin });
 }
 function digest(input, label) {
     if (typeof input !== 'string' || !/^sha256:[0-9a-f]{64}$/u.test(input)) {
@@ -229,21 +237,6 @@ function digest(input, label) {
     }
     return input;
 }
-function ref(input, mediaType, label) {
-    let admitted;
-    try {
-        admitted = artifact.accept(input);
-    }
-    catch (cause) {
-        throw new TypeError(`${label} Ref is invalid.`, { cause });
-    }
-    if (admitted.mediaType !== mediaType)
-        invalid(`${label} media type is invalid.`);
-    return admitted;
-}
-function same(left, right) {
-    return (left.digest === right.digest && left.mediaType === right.mediaType && left.size === right.size);
-}
 function boundedBytes(input, maximum, label) {
     if (!(input instanceof Uint8Array) || input.byteLength === 0 || input.byteLength > maximum) {
         invalid(`${label} evidence is invalid or exceeds its bound.`);
@@ -254,6 +247,12 @@ function admitLimit(input, label) {
     if (!Number.isSafeInteger(input) || input < 1)
         invalid(`${label} evidence bound is invalid.`);
 }
+function record(input, label) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        invalid(`${label} is invalid.`);
+    }
+    return input;
+}
 function exact(input, expected, label) {
     const keys = Object.keys(input).sort();
     const wanted = [...expected].sort();
@@ -261,13 +260,6 @@ function exact(input, expected, label) {
         invalid(`${label} fields are invalid.`);
     }
 }
-function equal(left, right) {
-    return left.byteLength === right.byteLength && left.every((byte, index) => byte === right[index]);
-}
-function isRecord(input) {
-    return input !== null && typeof input === 'object' && !Array.isArray(input);
-}
 function invalid(message) {
     throw new TypeError(message);
 }
-//# sourceMappingURL=codec.js.map

package/dist/schema/installation/introspection/index.d.ts

@@ -1,3 +1,2 @@
-export { MEDIA_TYPE, decode, encode } from './codec.js';
-export type { Digest, Installation, Limits, ResultFor, Source } from './result.js';
-//# sourceMappingURL=index.d.ts.map
+export { MEDIA_TYPE, acceptDomainDependencies, acceptDomainInfo, decode, encode } from './codec.js';
+export type { DependencyBinding, Digest, DomainBundle, DomainDependencies, DomainInfo, Limits, ResultFor, } from './result.js';

package/dist/schema/installation/introspection/index.js

@@ -1,2 +1 @@
-export { MEDIA_TYPE, decode, encode } from './codec.js';
-//# sourceMappingURL=index.js.map
+export { MEDIA_TYPE, acceptDomainDependencies, acceptDomainInfo, decode, encode } from './codec.js';

package/dist/schema/installation/introspection/result.d.ts

@@ -1,34 +1,47 @@
 import type { introspection } from '@astrale-os/kernel-core/schema';
-import type { bundle } from '@astrale-os/kernel-dsl/v1';
-import type { Ref } from '../../../artifact/index.js';
-import type { Publication } from '../../../publication/index.js';
-import type { PublicationRequirements } from '../../../publication/index.js';
+import type { bundle, Key, Revision } from '@astrale-os/kernel-dsl/v1';
+import type { Publication, PublicationRef, PublicationRequirements } from '../../../publication/index.js';
 export type Digest = `sha256:${string}`;
-export type Source = {
-    readonly kind: 'builtin';
-    readonly bundle: Ref;
-} | {
-    readonly kind: 'local';
-    readonly artifact: Ref;
-    readonly bundle: Ref;
-} | {
-    readonly kind: 'remote';
-    readonly publication: Publication;
-};
-export interface Installation {
-    readonly state: 'installed' | 'ready' | 'removing';
-    readonly target: Digest;
-    readonly source: Source;
-    readonly bundle: bundle.Bundle;
-    readonly readiness: Digest | null;
+/** Lightweight proof of one exact ready installed Domain generation. */
+export interface DomainInfo {
+    readonly origin: Key.Origin;
+    readonly revision: Revision;
+    readonly generation: Digest;
+    readonly publication: PublicationRef | null;
+    readonly readiness: Digest;
     readonly capabilities: {
         readonly requested: PublicationRequirements['capabilities'];
         readonly materialized: PublicationRequirements['capabilities'];
     };
+    readonly bindings: Publication['bindings'];
+}
+/** Explicit complete Bundle observed coherently with its ready Domain generation. */
+export interface DomainBundle {
+    readonly domain: DomainInfo;
+    readonly bundle: bundle.Bundle;
+}
+/**
+ * How one ready Domain generation binds one dependency of its exact closure: `exact` when the
+ * pinned revision is the one the Kernel serves, `retained` when the Kernel serves another revision
+ * and keeps the pinned one as inactive context admitted by unchanged meaning.
+ */
+export interface DependencyBinding {
+    readonly origin: Key.Origin;
+    readonly pinned: Revision;
+    readonly active: Revision;
+    readonly binding: 'exact' | 'retained';
+}
+/** The origin-ordered dependency bindings observed coherently with a ready Domain generation. */
+export interface DomainDependencies {
+    readonly domain: DomainInfo;
+    readonly dependencies: readonly DependencyBinding[];
 }
-export type ResultFor<Input extends introspection.Introspection> = Pick<Installation, Extract<keyof Input['select'], keyof Installation>> | null;
+export type ResultFor<Input extends introspection.Introspection> = Input extends {
+    readonly kind: 'bundle';
+} ? DomainBundle : Input extends {
+    readonly kind: 'dependencies';
+} ? DomainDependencies : DomainInfo;
 export interface Limits {
     readonly maximumPublicationBytes: number;
     readonly maximumBundleBytes: number;
 }
-//# sourceMappingURL=result.d.ts.map

package/dist/schema/installation/introspection/result.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=result.js.map

package/dist/schema/installation/result.d.ts

@@ -0,0 +1,9 @@
+import type { InstallReceipt } from '@astrale-os/kernel-core/schema/kernel/syscalls/contracts';
+import type { DomainInfo } from './introspection/index.js';
+export type InstallResult = {
+    readonly changed: true;
+    readonly receipt: InstallReceipt;
+} | {
+    readonly changed: false;
+    readonly domains: readonly [DomainInfo, ...DomainInfo[]];
+};

package/dist/schema/installation/result.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-protocol",
-  "version": "0.5.0-beta.6",
+  "version": "0.5.0-beta.61",
   "description": "Portable Astrale invocation, publication, installation, routing, and issuer protocols",
   "license": "Apache-2.0",
   "repository": {
@@ -59,6 +59,10 @@
       "types": "./dist/artifact/index.d.ts",
       "import": "./dist/artifact/index.js"
     },
+    "./publication": {
+      "types": "./dist/publication/index.d.ts",
+      "import": "./dist/publication/index.js"
+    },
     "./publication/publication": {
       "types": "./dist/publication/publication.d.ts",
       "import": "./dist/publication/publication.js"
@@ -67,6 +71,14 @@
       "types": "./dist/publication/reference.d.ts",
       "import": "./dist/publication/reference.js"
     },
+    "./publication/requirements": {
+      "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"
@@ -87,6 +99,10 @@
       "types": "./dist/routes/index.d.ts",
       "import": "./dist/routes/index.js"
     },
+    "./schema": {
+      "types": "./dist/schema/index.d.ts",
+      "import": "./dist/schema/index.js"
+    },
     "./routes/admission": {
       "types": "./dist/routes/admission.d.ts",
       "import": "./dist/routes/admission.js"
@@ -121,19 +137,18 @@
     "access": "public"
   },
   "dependencies": {
-    "@noble/hashes": "2.2.0",
-    "@astrale-os/kernel-core": "^0.9.0-beta.6",
-    "@astrale-os/kernel-dsl": "^0.2.0-beta.5"
+    "@astrale-os/kernel-core": "0.9.0-beta.55",
+    "@astrale-os/kernel-dsl": "0.2.0-beta.40",
+    "@noble/hashes": "2.3.0"
   },
   "devDependencies": {
     "@astrale/typescript-config": "npm:@jsr/astrale__typescript-config@~1.1.0",
-    "@typescript/native-preview": "latest",
-    "msgpackr": "^1.11.0",
-    "typescript": "~6.0.1-rc",
-    "vitest": "^3.0.0"
+    "msgpackr": "^2.0.5",
+    "typescript": "7.0.2",
+    "vitest": "^5.0.1"
   },
   "peerDependencies": {
-    "msgpackr": "^1.11.0"
+    "msgpackr": "^2.0.5"
   },
   "peerDependenciesMeta": {
     "msgpackr": {
@@ -141,12 +156,11 @@
     }
   },
   "scripts": {
-    "build": "tsgo",
+    "build": "tsc",
     "clean": "rm -rf dist",
-    "typecheck": "tsgo --noEmit",
+    "typecheck": "tsc --noEmit && tsc -p tsconfig.workers.json",
     "test": "vitest run",
     "test:file": "vitest run",
-    "test:watch": "vitest",
-    "preinstall": "node -e \"try{require('./.check-workspace.cjs')}catch{}\""
+    "test:watch": "vitest"
   }
 }