@astrale-os/kernel-core 0.9.0-beta.49 → 0.9.0-beta.50

package/dist/callable/invocation/call.d.ts

@@ -1,11 +1,16 @@
 import type { Key, Revision } from '@astrale-os/kernel-dsl/v1/addressing';
 import type { Value } from '@astrale-os/kernel-dsl/value';
 import { type NodePath } from '@astrale-os/kernel-core/path';
-/** One declaration, optionally bound to an instance and a declaring Domain revision. */
+/**
+ * One declaration, optionally bound to an instance and to the caller's expectation of it: the
+ * declaring Domain revision, or the fingerprint of the callable meaning it compiled against.
+ */
 export type Target = {
     readonly callable: Key.Callable;
     readonly instance?: NodePath;
+    /** @deprecated Pin the callable meaning with `fingerprint`; revision pinning will be removed. */
     readonly revision?: Revision;
+    readonly fingerprint?: `sha256:${string}`;
 };
 /** Capture a structured invocation target at a representation boundary. */
 export declare function Target(input: Target): Target;

package/dist/callable/invocation/call.js

@@ -1,12 +1,13 @@
 import { Path } from '@astrale-os/kernel-core/path';
 import { callableAddress, patterns } from '@astrale-os/kernel-dsl/v1/addressing';
+const FINGERPRINT_PATTERN = /^sha256:[0-9a-f]{64}$/u;
 /** Capture a structured invocation target at a representation boundary. */
 export function Target(input) {
     if (input === null ||
         typeof input !== 'object' ||
         Array.isArray(input) ||
-        Reflect.ownKeys(input).some((field) => !['callable', 'instance', 'revision'].includes(String(field)))) {
-        throw new TypeError('Invocation Target must contain only callable, instance and revision.');
+        Reflect.ownKeys(input).some((field) => !['callable', 'instance', 'revision', 'fingerprint'].includes(String(field)))) {
+        throw new TypeError('Invocation Target must contain only callable, instance, revision and fingerprint.');
     }
     const callable = input.callable;
     const coordinate = callableAddress(callable);
@@ -15,6 +16,11 @@ export function Target(input) {
         (typeof revision !== 'string' || !patterns.revision.test(revision))) {
         throw new TypeError('Invocation Target revision is invalid.');
     }
+    const fingerprint = input.fingerprint;
+    if (fingerprint !== undefined &&
+        (typeof fingerprint !== 'string' || !FINGERPRINT_PATTERN.test(fingerprint))) {
+        throw new TypeError('Invocation Target fingerprint is invalid.');
+    }
     const suppliedInstance = input.instance;
     const instance = suppliedInstance === undefined ? undefined : Path.parse(suppliedInstance);
     if (instance !== undefined &&
@@ -25,6 +31,7 @@ export function Target(input) {
         callable,
         ...(instance === undefined ? {} : { instance: instance.raw }),
         ...(revision === undefined ? {} : { revision }),
+        ...(fingerprint === undefined ? {} : { fingerprint }),
     });
 }
 /** Project an admitted target to its canonical graph path without discarding the original Call. */

package/dist/schema/callables/function.d.ts

@@ -33,6 +33,7 @@ export declare const Function: builder.NodeClass<{
                     callable: string;
                     instance?: string | undefined;
                     revision?: string | undefined;
+                    fingerprint?: string | undefined;
                 };
                 input: unknown;
             };
@@ -62,6 +63,7 @@ export declare const Function: builder.NodeClass<{
                 callable: string;
                 instance?: string | undefined;
                 revision?: string | undefined;
+                fingerprint?: string | undefined;
             };
             input: unknown;
         };

package/dist/schema/introspection/language.d.ts

@@ -6,4 +6,7 @@ export type Introspection = {
 } | {
     readonly kind: 'bundle';
     readonly origin: Key.Origin;
+} | {
+    readonly kind: 'dependencies';
+    readonly origin: Key.Origin;
 };

package/dist/schema/kernel/schema.d.ts

@@ -3632,6 +3632,7 @@ declare const KernelDefinitions: {
                             callable: string;
                             instance?: string | undefined;
                             revision?: string | undefined;
+                            fingerprint?: string | undefined;
                         };
                         input: unknown;
                     };
@@ -3661,6 +3662,7 @@ declare const KernelDefinitions: {
                         callable: string;
                         instance?: string | undefined;
                         revision?: string | undefined;
+                        fingerprint?: string | undefined;
                     };
                     input: unknown;
                 };
@@ -4548,7 +4550,7 @@ declare const KernelDefinitions: {
             readonly mode: 'binary';
         }, "authorized", false, false>>;
         introspect: builder.Function<builder.CallableProjection<{
-            kind: "bundle" | "inspect";
+            kind: "bundle" | "dependencies" | "inspect";
             origin: string;
         }, {
             readonly mode: 'binary';
@@ -4909,6 +4911,31 @@ export declare const AuthorityRelations: Readonly<{
 }>;
 /** Exact authorized Kernel Functions for which pristine Root receives direct can_use authority. */
 export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
+    operation: string;
+    domains: ({
+        artifact: {
+            digest: string;
+            mediaType: string;
+            size: number;
+        };
+        currentRevision?: string | null | undefined;
+    } | {
+        publication: {
+            url: string;
+            token?: string | undefined;
+            etag?: string | undefined;
+        };
+        revision?: string | undefined;
+        currentRevision?: string | null | undefined;
+    })[];
+}, {
+    readonly mode: 'binary';
+}, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>> & {
+    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"install"> & {
+        readonly origin: "kernel.astrale.ai";
+    };
+    readonly key: "kernel.astrale.ai:function.install";
+}) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
     invocation?: {
         source: string;
         id: string;
@@ -4940,259 +4967,6 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
         readonly origin: "kernel.astrale.ai";
     };
     readonly key: "kernel.astrale.ai:function.journal";
-}) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
-    idempotencyKey: string;
-    identities: ({
-        id: string;
-        mode: "external";
-        credential: string;
-    } | {
-        id: string;
-        mode: "self";
-        publicKey: unknown;
-        credential: string;
-    })[];
-}, {
-    readonly mode: 'value';
-    readonly value: {
-        identities: {
-            id: string;
-            iss: string;
-            sub: string;
-        }[];
-    };
-}, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>> & {
-    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"register"> & {
-        readonly origin: "kernel.astrale.ai";
-    };
-    readonly key: "kernel.astrale.ai:function.register";
-}) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
-    ast: {
-        format: "astrale.graph.query";
-        version: "v6";
-        source: {
-            kind: "node";
-            terms: ({
-                kind: "path";
-                path: string;
-            } | {
-                kind: "class";
-                class: {
-                    origin: string;
-                    kind: "class";
-                    name: string;
-                };
-            })[];
-            binding: string;
-        } | {
-            kind: "edge";
-            terms: {
-                kind: "class";
-                class: {
-                    origin: string;
-                    kind: "class";
-                    name: string;
-                };
-            }[];
-            bindings: {
-                source: string;
-                edge: string;
-                target: string;
-            };
-        };
-        steps: ({
-            op: "filter";
-            binding: string;
-            predicate: {
-                kind: "class.satisfies";
-                class: {
-                    origin: string;
-                    kind: "class";
-                    name: string;
-                };
-            } | {
-                kind: "class.equal";
-                class: {
-                    origin: string;
-                    kind: "class";
-                    name: string;
-                };
-            } | {
-                kind: "property.equal";
-                property: string;
-                value: unknown;
-            } | {
-                kind: "property.present";
-                property: string;
-            } | {
-                kind: "identity.equal";
-                identity: string | {
-                    source: string;
-                    target: string;
-                    class: string;
-                };
-            };
-        } | {
-            op: "expand";
-            from: string;
-            via: {
-                origin: string;
-                kind: "class";
-                name: string;
-            }[];
-            direction: "incident" | "incoming" | "outgoing";
-            bindings: {
-                edge: string;
-                node: string;
-            };
-        })[];
-        select: {
-            kind: "graph";
-            binding: string;
-            order?: {
-                property: string;
-                direction: "asc" | "desc";
-                unranked: "first" | "last";
-            } | undefined;
-        } | {
-            kind: "nodes";
-            binding: string;
-            projection: {
-                kind: "reference" | "value";
-            };
-            order?: {
-                property: string;
-                direction: "asc" | "desc";
-                unranked: "first" | "last";
-            } | undefined;
-        } | {
-            kind: "edges";
-            binding: string;
-            projection: {
-                edge: "reference" | "value";
-                source: "reference" | "value";
-                target: "reference" | "value";
-            };
-            order?: {
-                property: string;
-                direction: "asc" | "desc";
-                unranked: "first" | "last";
-            } | undefined;
-        };
-    };
-    expected?: {
-        origin: string;
-        revision: string;
-    }[] | undefined;
-    page: {
-        size: number;
-        after?: string | undefined;
-    };
-}, {
-    readonly mode: 'value';
-    readonly value: {
-        result: {
-            kind: "graph";
-            graph: {
-                nodes: {
-                    id: string;
-                    class: string;
-                    props: Record<string, unknown>;
-                }[];
-                edges: {
-                    source: string;
-                    target: string;
-                    class: string;
-                    slug?: import("../../graph/edge/index.js").EdgeSlug | undefined;
-                    props: Record<string, unknown>;
-                }[];
-            };
-            selection: {
-                kind: "node";
-                ids: string[];
-            } | {
-                kind: "edge";
-                keys: {
-                    source: string;
-                    target: string;
-                    class: string;
-                }[];
-            };
-        } | {
-            kind: "nodes";
-            nodes: ({
-                kind: "reference";
-                value: {
-                    id: string;
-                    class: string;
-                };
-            } | {
-                kind: "value";
-                value: {
-                    id: string;
-                    class: string;
-                    props: Record<string, unknown>;
-                };
-            })[];
-        } | {
-            kind: "edges";
-            edges: {
-                edge: {
-                    kind: "reference";
-                    value: {
-                        source: string;
-                        target: string;
-                        class: string;
-                    };
-                } | {
-                    kind: "value";
-                    value: {
-                        source: string;
-                        target: string;
-                        class: string;
-                        slug?: import("../../graph/edge/index.js").EdgeSlug | undefined;
-                        props: Record<string, unknown>;
-                    };
-                };
-                source: {
-                    kind: "reference";
-                    value: {
-                        id: string;
-                        class: string;
-                    };
-                } | {
-                    kind: "value";
-                    value: {
-                        id: string;
-                        class: string;
-                        props: Record<string, unknown>;
-                    };
-                };
-                target: {
-                    kind: "reference";
-                    value: {
-                        id: string;
-                        class: string;
-                    };
-                } | {
-                    kind: "value";
-                    value: {
-                        id: string;
-                        class: string;
-                        props: Record<string, unknown>;
-                    };
-                };
-            }[];
-        };
-        page: {
-            next?: string | undefined;
-        };
-    };
-}, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>> & {
-    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"query"> & {
-        readonly origin: "kernel.astrale.ai";
-    };
-    readonly key: "kernel.astrale.ai:function.query";
 }) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
     ast: {
         format: "astrale.graph.mutation";
@@ -5383,70 +5157,298 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
                 target: string;
                 class: string;
             };
-            slug: unknown;
-            props?: {
-                set: Record<string, unknown>;
-                unset: string[];
-            } | undefined;
+            slug: unknown;
+            props?: {
+                set: Record<string, unknown>;
+                unset: string[];
+            } | undefined;
+        } | {
+            op: "edge.update";
+            edge: {
+                source: string;
+                target: string;
+                class: string;
+            };
+            props: {
+                set: Record<string, unknown>;
+                unset: string[];
+            };
+        } | {
+            op: "edge.delete";
+            edge: {
+                source: string;
+                target: string;
+                class: string;
+            };
+        })[];
+    };
+    expected?: {
+        origin: string;
+        revision: string;
+    }[] | undefined;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        createdNodes: Record<string, string>;
+    };
+}, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>> & {
+    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"mutate"> & {
+        readonly origin: "kernel.astrale.ai";
+    };
+    readonly key: "kernel.astrale.ai:function.mutate";
+}) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
+    ast: {
+        format: "astrale.graph.query";
+        version: "v6";
+        source: {
+            kind: "node";
+            terms: ({
+                kind: "path";
+                path: string;
+            } | {
+                kind: "class";
+                class: {
+                    origin: string;
+                    kind: "class";
+                    name: string;
+                };
+            })[];
+            binding: string;
+        } | {
+            kind: "edge";
+            terms: {
+                kind: "class";
+                class: {
+                    origin: string;
+                    kind: "class";
+                    name: string;
+                };
+            }[];
+            bindings: {
+                source: string;
+                edge: string;
+                target: string;
+            };
+        };
+        steps: ({
+            op: "filter";
+            binding: string;
+            predicate: {
+                kind: "class.satisfies";
+                class: {
+                    origin: string;
+                    kind: "class";
+                    name: string;
+                };
+            } | {
+                kind: "class.equal";
+                class: {
+                    origin: string;
+                    kind: "class";
+                    name: string;
+                };
+            } | {
+                kind: "property.equal";
+                property: string;
+                value: unknown;
+            } | {
+                kind: "property.present";
+                property: string;
+            } | {
+                kind: "identity.equal";
+                identity: string | {
+                    source: string;
+                    target: string;
+                    class: string;
+                };
+            };
         } | {
-            op: "edge.update";
-            edge: {
-                source: string;
-                target: string;
-                class: string;
+            op: "expand";
+            from: string;
+            via: {
+                origin: string;
+                kind: "class";
+                name: string;
+            }[];
+            direction: "incident" | "incoming" | "outgoing";
+            bindings: {
+                edge: string;
+                node: string;
             };
-            props: {
-                set: Record<string, unknown>;
-                unset: string[];
+        })[];
+        select: {
+            kind: "graph";
+            binding: string;
+            order?: {
+                property: string;
+                direction: "asc" | "desc";
+                unranked: "first" | "last";
+            } | undefined;
+        } | {
+            kind: "nodes";
+            binding: string;
+            projection: {
+                kind: "reference" | "value";
             };
+            order?: {
+                property: string;
+                direction: "asc" | "desc";
+                unranked: "first" | "last";
+            } | undefined;
         } | {
-            op: "edge.delete";
-            edge: {
-                source: string;
-                target: string;
-                class: string;
+            kind: "edges";
+            binding: string;
+            projection: {
+                edge: "reference" | "value";
+                source: "reference" | "value";
+                target: "reference" | "value";
             };
-        })[];
+            order?: {
+                property: string;
+                direction: "asc" | "desc";
+                unranked: "first" | "last";
+            } | undefined;
+        };
     };
     expected?: {
         origin: string;
         revision: string;
     }[] | undefined;
+    page: {
+        size: number;
+        after?: string | undefined;
+    };
 }, {
     readonly mode: 'value';
     readonly value: {
-        createdNodes: Record<string, string>;
+        result: {
+            kind: "graph";
+            graph: {
+                nodes: {
+                    id: string;
+                    class: string;
+                    props: Record<string, unknown>;
+                }[];
+                edges: {
+                    source: string;
+                    target: string;
+                    class: string;
+                    slug?: import("../../graph/edge/index.js").EdgeSlug | undefined;
+                    props: Record<string, unknown>;
+                }[];
+            };
+            selection: {
+                kind: "node";
+                ids: string[];
+            } | {
+                kind: "edge";
+                keys: {
+                    source: string;
+                    target: string;
+                    class: string;
+                }[];
+            };
+        } | {
+            kind: "nodes";
+            nodes: ({
+                kind: "reference";
+                value: {
+                    id: string;
+                    class: string;
+                };
+            } | {
+                kind: "value";
+                value: {
+                    id: string;
+                    class: string;
+                    props: Record<string, unknown>;
+                };
+            })[];
+        } | {
+            kind: "edges";
+            edges: {
+                edge: {
+                    kind: "reference";
+                    value: {
+                        source: string;
+                        target: string;
+                        class: string;
+                    };
+                } | {
+                    kind: "value";
+                    value: {
+                        source: string;
+                        target: string;
+                        class: string;
+                        slug?: import("../../graph/edge/index.js").EdgeSlug | undefined;
+                        props: Record<string, unknown>;
+                    };
+                };
+                source: {
+                    kind: "reference";
+                    value: {
+                        id: string;
+                        class: string;
+                    };
+                } | {
+                    kind: "value";
+                    value: {
+                        id: string;
+                        class: string;
+                        props: Record<string, unknown>;
+                    };
+                };
+                target: {
+                    kind: "reference";
+                    value: {
+                        id: string;
+                        class: string;
+                    };
+                } | {
+                    kind: "value";
+                    value: {
+                        id: string;
+                        class: string;
+                        props: Record<string, unknown>;
+                    };
+                };
+            }[];
+        };
+        page: {
+            next?: string | undefined;
+        };
     };
 }, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>> & {
-    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"mutate"> & {
+    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"query"> & {
         readonly origin: "kernel.astrale.ai";
     };
-    readonly key: "kernel.astrale.ai:function.mutate";
+    readonly key: "kernel.astrale.ai:function.query";
 }) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
-    operation: string;
-    domains: ({
-        artifact: {
-            digest: string;
-            mediaType: string;
-            size: number;
-        };
-        currentRevision?: string | null | undefined;
+    idempotencyKey: string;
+    identities: ({
+        id: string;
+        mode: "external";
+        credential: string;
     } | {
-        publication: {
-            url: string;
-            token?: string | undefined;
-            etag?: string | undefined;
-        };
-        revision?: string | undefined;
-        currentRevision?: string | null | undefined;
+        id: string;
+        mode: "self";
+        publicKey: unknown;
+        credential: string;
     })[];
 }, {
-    readonly mode: 'binary';
+    readonly mode: 'value';
+    readonly value: {
+        identities: {
+            id: string;
+            iss: string;
+            sub: string;
+        }[];
+    };
 }, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>> & {
-    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"install"> & {
+    readonly ref: import("@astrale-os/kernel-dsl/v1").FunctionRef<"register"> & {
         readonly origin: "kernel.astrale.ai";
     };
-    readonly key: "kernel.astrale.ai:function.install";
+    readonly key: "kernel.astrale.ai:function.register";
 }) | (import("@astrale-os/kernel-dsl/v1").ResolvedFunction<{
     operation: string;
     domains: string[];
@@ -5503,32 +5505,6 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
 }, true, false, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.impersonate"> & {
     readonly name: "impersonate";
     readonly executable: true;
-}) | (import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
-    iss: string;
-    sub: string;
-}, {
-    readonly mode: 'value';
-    readonly value: {
-        id: string;
-        iss: string;
-        sub: string;
-        frozen: boolean;
-        requiredClaims: ({
-            claim: string;
-            op: "contains";
-            value: unknown;
-        } | {
-            claim: string;
-            op: "eq";
-            value: unknown;
-        } | {
-            claim: string;
-            op: "exists";
-        })[];
-    } | null;
-}, true, false, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
-    readonly name: "whois";
-    readonly executable: true;
 }) | (import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
     target: string;
 }, {
@@ -5571,6 +5547,32 @@ export declare const KernelRootFunctions: readonly ((import("@astrale-os/kernel-
 }, true, false, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>, "kernel.astrale.ai:class.View.method.resolve"> & {
     readonly name: "resolve";
     readonly executable: true;
+}) | (import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
+    iss: string;
+    sub: string;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        id: string;
+        iss: string;
+        sub: string;
+        frozen: boolean;
+        requiredClaims: ({
+            claim: string;
+            op: "contains";
+            value: unknown;
+        } | {
+            claim: string;
+            op: "eq";
+            value: unknown;
+        } | {
+            claim: string;
+            op: "exists";
+        })[];
+    } | null;
+}, true, false, "authorized", import("@astrale-os/kernel-dsl/v1").PolicyCheckExpression<import("@astrale-os/kernel-dsl/v1").PolicyRef, import("@astrale-os/kernel-dsl/v1/language").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
+    readonly name: "whois";
+    readonly executable: true;
 }))[];
 export { AuthorityOperationOrder, AuthorityOperations, operationOf } from '../authority/index.js';
 export type { AuthorityOperation, AuthorityRelation } from '../authority/index.js';

package/dist/schema/kernel/syscalls/contracts/admit.d.ts

@@ -4,6 +4,7 @@ export declare const admitInput: import("zod").ZodObject<{
             callable: import("zod").ZodString;
             instance: import("zod").ZodOptional<import("zod").ZodString>;
             revision: import("zod").ZodOptional<import("zod").ZodString>;
+            fingerprint: import("zod").ZodOptional<import("zod").ZodString>;
         }, import("zod/v4/core").$strict>]>;
         input: import("zod").ZodUnknown;
     }, import("zod/v4/core").$strict>;

package/dist/schema/kernel/syscalls/contracts/admit.js

@@ -6,7 +6,9 @@ export const admitInput = strictObject({
             strictObject({
                 callable: string().min(1),
                 instance: string().min(1).optional(),
+                // Deprecated revision pin, retained until every client pins by fingerprint.
                 revision: string().min(1).optional(),
+                fingerprint: string().min(1).optional(),
             }),
         ]),
         input: unknownSchema(),

package/dist/schema/kernel/syscalls/contracts/introspect.d.ts

@@ -1,6 +1,7 @@
 export declare const introspectInput: import("zod").ZodObject<{
     kind: import("zod").ZodEnum<{
         bundle: "bundle";
+        dependencies: "dependencies";
         inspect: "inspect";
     }>;
     origin: import("zod").ZodString;

package/dist/schema/kernel/syscalls/contracts/introspect.js

@@ -1,5 +1,5 @@
 import { enum as enumeration, strictObject, string } from 'zod';
 export const introspectInput = strictObject({
-    kind: enumeration(['inspect', 'bundle']),
+    kind: enumeration(['inspect', 'bundle', 'dependencies']),
     origin: string().min(1),
 });

package/dist/schema/kernel/syscalls/declarations/admit.d.ts

@@ -5,6 +5,7 @@ export declare const Admit: builder.Method<builder.CallableProjection<{
             callable: string;
             instance?: string | undefined;
             revision?: string | undefined;
+            fingerprint?: string | undefined;
         };
         input: unknown;
     };

package/dist/schema/kernel/syscalls/declarations/index.d.ts

@@ -492,7 +492,7 @@ export declare const Functions: Readonly<{
         readonly mode: 'binary';
     }, "authorized", false, false>>;
     introspect: builder.Function<builder.CallableProjection<{
-        kind: "bundle" | "inspect";
+        kind: "bundle" | "dependencies" | "inspect";
         origin: string;
     }, {
         readonly mode: 'binary';
@@ -656,6 +656,7 @@ export declare const FunctionMethods: Readonly<{
                 callable: string;
                 instance?: string | undefined;
                 revision?: string | undefined;
+                fingerprint?: string | undefined;
             };
             input: unknown;
         };

package/dist/schema/kernel/syscalls/declarations/introspect.d.ts

@@ -1,6 +1,6 @@
 import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const Introspect: builder.Function<builder.CallableProjection<{
-    kind: "bundle" | "inspect";
+    kind: "bundle" | "dependencies" | "inspect";
     origin: string;
 }, {
     readonly mode: 'binary';

package/dist/schema/kernel/syscalls/descriptors/function.d.ts

@@ -6,6 +6,7 @@ declare const Admit: import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
             callable: string;
             instance?: string | undefined;
             revision?: string | undefined;
+            fingerprint?: string | undefined;
         };
         input: unknown;
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-core",
-  "version": "0.9.0-beta.49",
+  "version": "0.9.0-beta.50",
   "description": "Astrale Kernel Core - Types, Invariants, and Pure Logic",
   "license": "Apache-2.0",
   "repository": {
@@ -160,7 +160,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@astrale-os/kernel-dsl": "0.2.0-beta.34",
+    "@astrale-os/kernel-dsl": "0.2.0-beta.35",
     "@noble/hashes": "2.3.0",
     "@types/json-schema": "^7.0.15",
     "dequal": "2.0.3"