@astrale-os/kernel-core 0.9.0-beta.63 → 0.9.0-beta.65

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

@@ -2,6 +2,9 @@ export declare const delegateInput: import("zod").ZodObject<{
     principal: import("zod").ZodString;
     audience: import("zod").ZodString;
     ttlSeconds: import("zod").ZodNumber;
-    attenuation: import("zod").ZodOptional<import("zod").ZodUnknown>;
+    attenuation: import("zod").ZodOptional<import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"identity">;
+        self: import("zod").ZodLiteral<true>;
+    }, import("zod/v4/core").$strict>>;
 }, import("zod/v4/core").$strict>;
 export declare const delegateOutput: import("zod").ZodString;

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

@@ -1,10 +1,11 @@
-import { number, strictObject, string, unknown as unknownSchema } from 'zod';
+import { number, strictObject, string } from 'zod';
+import { selfAttenuation } from './legacy/delegate.js';
 const text = string().min(1);
 export const delegateInput = strictObject({
     principal: text,
     audience: text,
     ttlSeconds: number().int().min(1),
-    /** Optional; absence means the self expression. */
-    attenuation: unknownSchema().optional(),
+    /** @deprecated Ignored; admitted only as the self expression published Clients send. */
+    attenuation: selfAttenuation.optional(),
 });
 export const delegateOutput = text;

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

@@ -1,7 +1,6 @@
 export declare const impersonateInput: import("zod").ZodObject<{
     audience: import("zod").ZodOptional<import("zod").ZodString>;
     ttlSeconds: import("zod").ZodNumber;
-    grant: import("zod").ZodOptional<import("zod").ZodUnknown>;
     identity: import("zod").ZodString;
 }, import("zod/v4/core").$strict>;
 export declare const impersonateOutput: import("zod").ZodString;

package/dist/schema/kernel/syscalls/contracts/legacy/delegate.d.ts

@@ -0,0 +1,5 @@
+/** @deprecated The only `attenuation` value `Identity.delegate` still admits, and ignores. */
+export declare const selfAttenuation: import("zod").ZodObject<{
+    kind: import("zod").ZodLiteral<"identity">;
+    self: import("zod").ZodLiteral<true>;
+}, import("zod/v4/core").$strict>;

package/dist/schema/kernel/syscalls/contracts/legacy/delegate.js

@@ -0,0 +1,25 @@
+/**
+ * `Identity.delegate` keeps admitting the one `attenuation` value published Clients send: the self
+ * expression `{ kind: 'identity', self: true }`. It names the caller the delegation preserves
+ * anyway, so it carries no meaning: the handler ignores it and issues exactly the credential the
+ * same input without the field yields. Every other value, `null` included, stays refused.
+ *
+ * @deprecated Omit `attenuation`; a delegation always preserves the authenticated caller (ADR-3).
+ *
+ * Short-term consumers: `@astrale-os/kernel-client` 0.6.0-beta.77 to beta.85, whose Domain token
+ * exchange always sends it (`client/session/exchange/exchange.ts`, `SELF_ATTENUATION`), so the
+ * Console, the GUI, the Admin upgrade executor and the CLI through 1.0.0-beta.126 (exchange and
+ * `astrale token`). The 1Pact Host runs Kernel 0.12.0-beta.117, which requires the field, so a
+ * Client that serves both Kernels sends it.
+ *
+ * Removal, in a separate breaking release, once every consumer runs a Client that omits the field
+ * and the 0.12.0-beta.117 consumer Host is retired: delete this file and the `attenuation` member
+ * of `../delegate.ts`, then make the self vectors of TEST-REJECTS-AUTHORITY-EXPRESSIONS-IN-ISSUANCE-INPUTS
+ * and of the SYS-6 dispatch test expect refusal again.
+ */
+import { literal, strictObject } from 'zod';
+/** @deprecated The only `attenuation` value `Identity.delegate` still admits, and ignores. */
+export const selfAttenuation = strictObject({
+    kind: literal('identity'),
+    self: literal(true),
+}).meta({ deprecated: true });

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

@@ -1,6 +1,5 @@
 export declare const mintInput: import("zod").ZodObject<{
     audience: import("zod").ZodOptional<import("zod").ZodString>;
     ttlSeconds: import("zod").ZodNumber;
-    grant: import("zod").ZodOptional<import("zod").ZodUnknown>;
 }, import("zod/v4/core").$strict>;
 export declare const mintOutput: import("zod").ZodString;

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

@@ -1,8 +1,7 @@
-import { number, strictObject, string, unknown as unknownSchema } from 'zod';
+import { number, strictObject, string } from 'zod';
 const text = string().min(1);
 export const mintInput = strictObject({
     audience: text.optional(),
     ttlSeconds: number().int().min(1),
-    grant: unknownSchema().optional(),
 });
 export const mintOutput = text;

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

@@ -3,7 +3,10 @@ export declare const Delegate: builder.Method<builder.CallableProjection<{
     principal: string;
     audience: string;
     ttlSeconds: number;
-    attenuation?: unknown;
+    attenuation?: {
+        kind: "identity";
+        self: true;
+    } | undefined;
 }, {
     readonly mode: 'value';
     readonly value: string;

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

@@ -2,7 +2,6 @@ import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const Impersonate: builder.Method<builder.CallableProjection<{
     audience?: string | undefined;
     ttlSeconds: number;
-    grant?: unknown;
     identity: string;
 }, {
     readonly mode: 'value';

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

@@ -399,29 +399,6 @@ export declare const Functions: Readonly<{
                 };
             })[];
             operations: ({
-                op: "edge.update";
-                edge: {
-                    source: string;
-                    target: string;
-                    class: string;
-                };
-                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: "node.create";
                 as: string;
                 class: string;
@@ -449,6 +426,29 @@ export declare const Functions: Readonly<{
                 };
                 slug?: unknown;
                 props: Record<string, unknown>;
+            } | {
+                op: "edge.update";
+                edge: {
+                    source: string;
+                    target: string;
+                    class: string;
+                };
+                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: {
@@ -493,6 +493,14 @@ export declare const Functions: Readonly<{
     install: builder.Function<builder.CallableProjection<{
         operation: string;
         domains: ({
+            publication: {
+                url: string;
+                token?: string | undefined;
+                etag?: string | undefined;
+            };
+            revision?: string | undefined;
+            currentRevision?: string | null | undefined;
+        } | {
             artifact: {
                 digest: string;
                 mediaType: string;
@@ -514,14 +522,6 @@ export declare const Functions: Readonly<{
             } | undefined;
             revision?: string | undefined;
             currentRevision?: string | null | undefined;
-        } | {
-            publication: {
-                url: string;
-                token?: string | undefined;
-                etag?: string | undefined;
-            };
-            revision?: string | undefined;
-            currentRevision?: string | null | undefined;
         })[];
     }, {
         readonly mode: 'binary';
@@ -616,7 +616,10 @@ export declare const IdentityMethods: Readonly<{
         principal: string;
         audience: string;
         ttlSeconds: number;
-        attenuation?: unknown;
+        attenuation?: {
+            kind: "identity";
+            self: true;
+        } | undefined;
     }, {
         readonly mode: 'value';
         readonly value: string;
@@ -687,7 +690,6 @@ export declare const IdentityMethods: Readonly<{
     mint: builder.Method<builder.CallableProjection<{
         audience?: string | undefined;
         ttlSeconds: number;
-        grant?: unknown;
     }, {
         readonly mode: 'value';
         readonly value: string;
@@ -695,7 +697,6 @@ export declare const IdentityMethods: Readonly<{
     impersonate: builder.Method<builder.CallableProjection<{
         audience?: string | undefined;
         ttlSeconds: number;
-        grant?: unknown;
         identity: string;
     }, {
         readonly mode: 'value';

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

@@ -2,6 +2,14 @@ import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const Install: builder.Function<builder.CallableProjection<{
     operation: string;
     domains: ({
+        publication: {
+            url: string;
+            token?: string | undefined;
+            etag?: string | undefined;
+        };
+        revision?: string | undefined;
+        currentRevision?: string | null | undefined;
+    } | {
         artifact: {
             digest: string;
             mediaType: string;
@@ -23,14 +31,6 @@ export declare const Install: builder.Function<builder.CallableProjection<{
         } | undefined;
         revision?: string | undefined;
         currentRevision?: string | null | undefined;
-    } | {
-        publication: {
-            url: string;
-            token?: string | undefined;
-            etag?: string | undefined;
-        };
-        revision?: string | undefined;
-        currentRevision?: string | null | undefined;
     })[];
 }, {
     readonly mode: 'binary';

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

@@ -2,7 +2,6 @@ import { type builder } from '@astrale-os/kernel-dsl/v1';
 export declare const Mint: builder.Method<builder.CallableProjection<{
     audience?: string | undefined;
     ttlSeconds: number;
-    grant?: unknown;
 }, {
     readonly mode: 'value';
     readonly value: string;

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

@@ -155,29 +155,6 @@ export declare const Mutate: builder.Function<builder.CallableProjection<{
             };
         })[];
         operations: ({
-            op: "edge.update";
-            edge: {
-                source: string;
-                target: string;
-                class: string;
-            };
-            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: "node.create";
             as: string;
             class: string;
@@ -205,6 +182,29 @@ export declare const Mutate: builder.Function<builder.CallableProjection<{
             };
             slug?: unknown;
             props: Record<string, unknown>;
+        } | {
+            op: "edge.update";
+            edge: {
+                source: string;
+                target: string;
+                class: string;
+            };
+            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: {

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

@@ -6,7 +6,10 @@ export declare const delegate: import("./model.js").MethodSyscall<Readonly<{
     principal: string;
     audience: string;
     ttlSeconds: number;
-    attenuation?: unknown;
+    attenuation?: {
+        kind: "identity";
+        self: true;
+    } | undefined;
 }, {
     readonly mode: 'value';
     readonly value: string;
@@ -109,7 +112,6 @@ export declare const impersonate: import("./model.js").MethodSyscall<Readonly<{
 }>, "impersonate", import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
     audience?: string | undefined;
     ttlSeconds: number;
-    grant?: unknown;
     identity: string;
 }, {
     readonly mode: 'value';
@@ -126,7 +128,6 @@ export declare const mint: import("./model.js").MethodSyscall<Readonly<{
 }>, "mint", import("@astrale-os/kernel-dsl/v1").ResolvedMethod<{
     audience?: string | undefined;
     ttlSeconds: number;
-    grant?: unknown;
 }, {
     readonly mode: 'value';
     readonly value: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-core",
-  "version": "0.9.0-beta.63",
+  "version": "0.9.0-beta.65",
   "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.45",
+    "@astrale-os/kernel-dsl": "0.2.0-beta.47",
     "@noble/hashes": "2.3.0",
     "@types/json-schema": "^7.0.15",
     "dequal": "2.0.3"

package/dist/auth/authority/prepare-grant-body.d.ts

@@ -1,4 +0,0 @@
-import type { Grant } from '../grant/index.js';
-import type { AuthorityExpr, AuthorityPredicate } from './language/index.js';
-/** Prepare one body in a fresh Grant subject scope, independently of any concrete Grant. */
-export declare function prepareGrantBody(where: AuthorityExpr): (grant: Grant) => AuthorityPredicate;

package/dist/auth/authority/prepare-grant-body.js

@@ -1,27 +0,0 @@
-import * as portable from '@astrale-os/kernel-dsl/value';
-import { accept as acceptGrant, canonicalize as canonicalizeGrant } from '../grant/index.js';
-import { admitGrantBody } from './admission/index.js';
-import { AUTHORITY_PREDICATE_VERSION } from './language/index.js';
-import { normalizeGrantBodyAdmitted } from './normalization/index.js';
-import { ownCanonical } from './ownership.optimization.js';
-/** Prepare one body in a fresh Grant subject scope, independently of any concrete Grant. */
-export function prepareGrantBody(where) {
-    const admitted = admitGrantBody(portable.acceptForRead(where));
-    const body = portable.acceptImmutable(normalizeGrantBodyAdmitted(admitted));
-    return grantBinder(body);
-}
-// A distinct closure scope retains only the normalized body, never an initial Grant or caller input.
-function grantBinder(where) {
-    return (grant) => {
-        // Charge the entire expression on every binding, including the body and its outer container.
-        const value = portable.acceptForRead({ op: 'grant', grant, where });
-        return ownCanonical(Object.freeze({
-            version: AUTHORITY_PREDICATE_VERSION,
-            predicate: Object.freeze({
-                op: 'grant',
-                grant: canonicalizeGrant(acceptGrant(value.grant)),
-                where,
-            }),
-        }));
-    };
-}

package/dist/auth/expression/normalization/canonicalize.d.ts

@@ -1,7 +0,0 @@
-import * as portable from '@astrale-os/kernel-dsl/value';
-import type { IdentityExpr } from '../language/index.js';
-export declare const EXPRESSION_DEPTH_LIMIT = 32;
-export declare const EXPRESSION_OPERAND_LIMIT = 64;
-/** Validate and canonicalize a resolved expression. */
-export declare function canonicalize(expr: IdentityExpr): IdentityExpr;
-export declare function admitResolvedExpression(input: portable.Value, path: string, depth: number): IdentityExpr;

package/dist/auth/expression/normalization/canonicalize.js

@@ -1,102 +0,0 @@
-import * as portable from '@astrale-os/kernel-dsl/value';
-import { NodeId } from '../../../graph/node/index.js';
-import { AuthValueError } from '../../error.js';
-export const EXPRESSION_DEPTH_LIMIT = 32;
-export const EXPRESSION_OPERAND_LIMIT = 64;
-/** Validate and canonicalize a resolved expression. */
-export function canonicalize(expr) {
-    try {
-        return admit(portable.accept(expr), '', 0);
-    }
-    catch (cause) {
-        if (cause instanceof AuthValueError)
-            throw cause;
-        throw new AuthValueError('AUTH_GRANT_INVALID', 'Expected a resolved Identity expression', '', {
-            cause,
-        });
-    }
-}
-export function admitResolvedExpression(input, path, depth) {
-    return admit(input, path, depth);
-}
-function admit(input, path, depth) {
-    if (depth > EXPRESSION_DEPTH_LIMIT)
-        invalid(path, 'Identity expression exceeds its depth limit');
-    const value = record(input, path);
-    switch (value.kind) {
-        case 'identity':
-            exact(value, ['id', 'kind'], path);
-            if (typeof value.id !== 'string')
-                invalid(`${path}/id`, 'Expected a NodeId');
-            return Object.freeze({ kind: 'identity', id: NodeId(value.id) });
-        case 'union':
-        case 'intersect': {
-            exact(value, ['kind', 'operands'], path);
-            const source = list(value.operands, `${path}/operands`, 2);
-            const kind = value.kind;
-            const operands = unique(source
-                .map((operand, index) => admit(operand, `${path}/operands/${index}`, depth + 1))
-                .flatMap((operand) => (operand.kind === kind ? operand.operands : [operand])));
-            if (operands.length > EXPRESSION_OPERAND_LIMIT) {
-                invalid(`${path}/operands`, `Expected 2-${EXPRESSION_OPERAND_LIMIT} operands`);
-            }
-            return operands.length === 1
-                ? operands[0]
-                : Object.freeze({ kind, operands: Object.freeze(operands) });
-        }
-        case 'exclude': {
-            exact(value, ['base', 'excluded', 'kind'], path);
-            const excluded = unique(list(value.excluded, `${path}/excluded`, 1)
-                .map((operand, index) => admit(operand, `${path}/excluded/${index}`, depth + 1))
-                .flatMap((operand) => (operand.kind === 'union' ? operand.operands : [operand])));
-            if (excluded.length > EXPRESSION_OPERAND_LIMIT) {
-                invalid(`${path}/excluded`, `Expected 1-${EXPRESSION_OPERAND_LIMIT} operands`);
-            }
-            return Object.freeze({
-                kind: 'exclude',
-                base: admit(required(value.base, `${path}/base`), `${path}/base`, depth + 1),
-                excluded: Object.freeze(excluded),
-            });
-        }
-        default:
-            invalid(`${path}/kind`, 'Expected identity, union, intersect, or exclude');
-    }
-}
-function unique(input) {
-    const keyed = input
-        .map((expr) => ({ expr, key: portable.json.serialize(expr) }))
-        .sort((left, right) => compare(left.key, right.key));
-    return keyed
-        .filter((entry, index) => index === 0 || entry.key !== keyed[index - 1].key)
-        .map((entry) => entry.expr);
-}
-function record(input, path) {
-    if (input === null || Array.isArray(input) || typeof input !== 'object') {
-        invalid(path, 'Expected an object');
-    }
-    return input;
-}
-function list(input, path, minimum) {
-    if (!Array.isArray(input) || input.length < minimum || input.length > EXPRESSION_OPERAND_LIMIT) {
-        invalid(path, `Expected ${minimum}-${EXPRESSION_OPERAND_LIMIT} operands`);
-    }
-    return input;
-}
-function required(input, path) {
-    if (input === undefined)
-        invalid(path, 'Expected a value');
-    return input;
-}
-function exact(value, expected, path) {
-    const actual = Object.keys(value).sort(compare);
-    const wanted = [...expected].sort(compare);
-    if (actual.length !== wanted.length || actual.some((key, index) => key !== wanted[index])) {
-        invalid(path, `Expected exactly ${expected.join(', ')}`);
-    }
-}
-function compare(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}
-function invalid(path, message) {
-    throw new AuthValueError('AUTH_GRANT_INVALID', message, path);
-}

package/dist/auth/expression/normalization/index.d.ts

@@ -1,2 +0,0 @@
-export { admitResolvedExpression, canonicalize, EXPRESSION_DEPTH_LIMIT, EXPRESSION_OPERAND_LIMIT, } from './canonicalize.js';
-export { raiseDenials } from './raise-denials.js';

package/dist/auth/expression/normalization/index.js

@@ -1,2 +0,0 @@
-export { admitResolvedExpression, canonicalize, EXPRESSION_DEPTH_LIMIT, EXPRESSION_OPERAND_LIMIT, } from './canonicalize.js';
-export { raiseDenials } from './raise-denials.js';

package/dist/auth/expression/normalization/raise-denials.d.ts

@@ -1,3 +0,0 @@
-import type { IdentityExpr } from '../language/index.js';
-/** Raise every positive-position exclusion into one Grant-wide veto. */
-export declare function raiseDenials(expr: IdentityExpr): IdentityExpr;

package/dist/auth/expression/normalization/raise-denials.js

@@ -1,59 +0,0 @@
-/** Raise every positive-position exclusion into one Grant-wide veto. */
-export function raiseDenials(expr) {
-    const denials = [...collectDenials(expr, new WeakMap())];
-    if (denials.length === 0)
-        return expr;
-    return Object.freeze({
-        kind: 'exclude',
-        base: stripExcludes(expr, new WeakMap()),
-        excluded: Object.freeze(denials),
-    });
-}
-function stripExcludes(expr, memo) {
-    const cached = memo.get(expr);
-    if (cached !== undefined)
-        return cached;
-    let stripped;
-    switch (expr.kind) {
-        case 'identity':
-            stripped = expr;
-            break;
-        case 'union':
-        case 'intersect':
-            stripped = Object.freeze({
-                kind: expr.kind,
-                operands: Object.freeze(expr.operands.map((operand) => stripExcludes(operand, memo))),
-            });
-            break;
-        case 'exclude':
-            stripped = stripExcludes(expr.base, memo);
-            break;
-    }
-    memo.set(expr, stripped);
-    return stripped;
-}
-function collectDenials(expr, memo) {
-    const cached = memo.get(expr);
-    if (cached !== undefined)
-        return cached;
-    const denials = new Set();
-    switch (expr.kind) {
-        case 'identity':
-            break;
-        case 'union':
-        case 'intersect':
-            for (const operand of expr.operands) {
-                for (const denial of collectDenials(operand, memo))
-                    denials.add(denial);
-            }
-            break;
-        case 'exclude':
-            for (const excluded of expr.excluded)
-                denials.add(excluded);
-            for (const denial of collectDenials(expr.base, memo))
-                denials.add(denial);
-            break;
-    }
-    memo.set(expr, denials);
-    return denials;
-}

package/dist/graph/graph/navigation/error.d.ts

@@ -1,12 +0,0 @@
-import type { NodePath } from '../../path/index.js';
-export declare class GraphPathAmbiguousError extends Error {
-    readonly path: NodePath;
-    readonly matches: number;
-    readonly code: 'GRAPH_PATH_AMBIGUOUS';
-    constructor(path: NodePath, matches: number);
-}
-export declare class GraphPathWalkerRequiredError extends Error {
-    readonly path: NodePath;
-    readonly code: 'GRAPH_PATH_WALKER_REQUIRED';
-    constructor(path: NodePath);
-}

package/dist/graph/graph/navigation/error.js

@@ -1,20 +0,0 @@
-export class GraphPathAmbiguousError extends Error {
-    path;
-    matches;
-    code = 'GRAPH_PATH_AMBIGUOUS';
-    constructor(path, matches) {
-        super(`Graph Path ${JSON.stringify(path)} matched ${matches} distinct Nodes.`);
-        this.path = path;
-        this.matches = matches;
-        this.name = 'GraphPathAmbiguousError';
-    }
-}
-export class GraphPathWalkerRequiredError extends Error {
-    path;
-    code = 'GRAPH_PATH_WALKER_REQUIRED';
-    constructor(path) {
-        super(`Graph Path ${JSON.stringify(path)} requires a walker.`);
-        this.path = path;
-        this.name = 'GraphPathWalkerRequiredError';
-    }
-}

package/dist/graph/graph/navigation/index.d.ts

@@ -1,2 +0,0 @@
-export type { GraphPathContext, GraphPathWalker } from './model.js';
-export { GraphPathAmbiguousError, GraphPathWalkerRequiredError } from './error.js';

package/dist/graph/graph/navigation/index.js

@@ -1 +0,0 @@
-export { GraphPathAmbiguousError, GraphPathWalkerRequiredError } from './error.js';

package/dist/graph/graph/navigation/model.d.ts

@@ -1,15 +0,0 @@
-import type { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
-import type { EdgeOrientation } from '@astrale-os/kernel-dsl/v1/language';
-import type { Node } from '../../node/index.js';
-import type { Path } from '../../path/index.js';
-import type { GraphEdges, GraphNodes } from '../indexes/index.js';
-/** Semantic read-only graph capabilities available to a Path walker. */
-export interface GraphPathContext {
-    readonly nodes: GraphNodes;
-    readonly edges: GraphEdges;
-    orientation(classKey: ClassKey): EdgeOrientation | undefined;
-}
-/** Pure injected semantics for walking one Path against an admitted Graph. */
-export interface GraphPathWalker {
-    walk(path: Path, context: GraphPathContext): Node | undefined;
-}

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

@@ -1,2 +0,0 @@
-import type { GraphPathWalker } from '#graph/graph';
-export declare const projectionPathWalker: GraphPathWalker;