@astrale-os/kernel-core 0.9.0-beta.43 → 0.9.0-beta.45

package/dist/callable/index.d.ts

@@ -1,2 +1,2 @@
 export type { BinaryOutput, BufferedBinaryResult, Callable, CallableSignature, CallOf, InputOf, OutputContractOf, OutputOf, SignatureOf, StreamingBinaryResult, TypedCallableOutput, } from './contract/index.js';
-export type { Call, CallableResult } from './invocation/index.js';
+export { Target, targetPath, type Call, type CallableResult } from './invocation/index.js';

package/dist/callable/index.js

@@ -1 +1 @@
-export {};
+export { Target, targetPath } from './invocation/index.js';

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

@@ -1,7 +1,18 @@
-import type { NodePath } from '@astrale-os/kernel-core/path';
+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. */
+export type Target = {
+    readonly callable: Key.Callable;
+    readonly instance?: NodePath;
+    readonly revision?: Revision;
+};
+/** Capture a structured invocation target at a representation boundary. */
+export declare function Target(input: Target): Target;
+/** Project an admitted target to its canonical graph path without discarding the original Call. */
+export declare function targetPath(target: NodePath | Target): NodePath;
 /** One canonical callable invocation meaning, independent of its carrier. */
 export interface Call {
-    readonly target: NodePath;
+    readonly target: NodePath | Target;
     readonly input: Value;
 }

package/dist/callable/invocation/call.js

@@ -1 +1,40 @@
-export {};
+import { Path } from '@astrale-os/kernel-core/path';
+import { callableAddress, patterns } from '@astrale-os/kernel-dsl/v1/addressing';
+/** 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.');
+    }
+    const callable = input.callable;
+    const coordinate = callableAddress(callable);
+    const revision = input.revision;
+    if (revision !== undefined &&
+        (typeof revision !== 'string' || !patterns.revision.test(revision))) {
+        throw new TypeError('Invocation Target revision is invalid.');
+    }
+    const suppliedInstance = input.instance;
+    const instance = suppliedInstance === undefined ? undefined : Path.parse(suppliedInstance);
+    if (instance !== undefined &&
+        (coordinate.kind !== 'method' || instance.ast.steps.at(-1)?.kind === 'method')) {
+        throw new TypeError('Only an instance Method target can carry a node instance path.');
+    }
+    return Object.freeze({
+        callable,
+        ...(instance === undefined ? {} : { instance: instance.raw }),
+        ...(revision === undefined ? {} : { revision }),
+    });
+}
+/** Project an admitted target to its canonical graph path without discarding the original Call. */
+export function targetPath(target) {
+    if (typeof target === 'string')
+        return target;
+    const coordinate = callableAddress(target.callable);
+    if (coordinate.kind === 'function')
+        return Path.project(coordinate).raw;
+    return target.instance === undefined
+        ? Path.staticMethod(Path.project(coordinate.owner), coordinate.name).raw
+        : Path.instanceMethod(Path.parse(target.instance), target.callable).raw;
+}

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

@@ -1,2 +1,2 @@
-export type { Call } from './call.js';
+export { Target, targetPath, type Call } from './call.js';
 export type { CallableResult } from './result.js';

package/dist/callable/invocation/index.js

@@ -1 +1 @@
-export {};
+export { Target, targetPath } from './call.js';

package/dist/graph/path/authoring/path.d.ts

@@ -1,4 +1,5 @@
 import type { DefinitionRef, Key } from '@astrale-os/kernel-dsl/v1/addressing';
+import { MethodKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import { type ClassKey as ClassKeyValue } from '@astrale-os/kernel-dsl/v1/addressing';
 import type { NodeId } from '../../node/identity/index.js';
 import type { DomainAnchor as PathDomainAnchor, DomainProjection as PathDomainProjection, IdAnchor as PathIdAnchor, MethodStep as PathMethodStep, NodePath, PathAST, PathAnchor, PathDiagnostic, PathDiagnosticCode, PathStep, ProjectionKind as PathProjectionKind, ProjectionStep as PathProjectionStep, TraversalStep as PathTraversalStep } from '../language/index.js';
@@ -19,7 +20,7 @@ export declare class Path {
     static domain(origin: Key.Origin): Path.Domain;
     static project(input: ClassKeyValue | Path.ProjectionRef): Path.Projection;
     static staticMethod(owner: Path.Projection, name: string): Path.Method;
-    static instanceMethod(source: Path, name: string): Path.Method;
+    static instanceMethod(source: Path, callable: MethodKey): Path.Method;
     out(classKey: ClassKeyValue, options?: Path.TraversalOptions): Path;
     in(classKey: ClassKeyValue, options?: Path.TraversalOptions): Path;
     equals(other: Path): boolean;

package/dist/graph/path/authoring/path.js

@@ -1,3 +1,4 @@
+import { MethodKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import { ClassKey, isDefinitionRef, } from '@astrale-os/kernel-dsl/v1/addressing';
 import { EdgeSlug } from '../../edge/slug/index.js';
 import { isNodeId } from '../../node/identity/index.js';
@@ -51,10 +52,14 @@ export class Path {
             steps: [...owner.ast.steps, { kind: 'method', dispatch: 'static', name }],
         }));
     }
-    static instanceMethod(source, name) {
+    static instanceMethod(source, callable) {
+        const { owner, name } = MethodKey.address(callable);
         return createPath(normalizePathAST({
             anchor: source.ast.anchor,
-            steps: [...source.ast.steps, { kind: 'method', dispatch: 'instance', name }],
+            steps: [
+                ...source.ast.steps,
+                { kind: 'method', dispatch: 'instance', class: ClassKey.of(owner), name },
+            ],
         }));
     }
     out(classKey, options = {}) {

package/dist/graph/path/language/model.d.ts

@@ -25,11 +25,16 @@ export interface ProjectionStep {
     readonly kind: 'projection';
     readonly projection: DomainProjection;
 }
-export interface MethodStep {
+export type MethodStep = {
     readonly kind: 'method';
-    readonly dispatch: 'static' | 'instance';
+    readonly dispatch: 'static';
     readonly name: string;
-}
+} | {
+    readonly kind: 'method';
+    readonly dispatch: 'instance';
+    readonly class: ClassKey;
+    readonly name: string;
+};
 export interface TraversalStep {
     readonly kind: 'traverse';
     readonly direction: 'out' | 'in';

package/dist/graph/path/language/syntax.js

@@ -1,4 +1,4 @@
-import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
+import { patterns, MethodKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import { EdgeSlug, isEdgeSlug } from '../../edge/slug/index.js';
 import { isNodeId } from '../../node/identity/index.js';
@@ -34,7 +34,9 @@ export function normalizePathAST(input) {
             continue;
         }
         if (candidate.kind === 'method') {
-            if (!hasExactKeys(candidate, ['kind', 'dispatch', 'name']))
+            if (!hasExactKeys(candidate, candidate.dispatch === 'instance'
+                ? ['kind', 'dispatch', 'class', 'name']
+                : ['kind', 'dispatch', 'name']))
                 invalidAST();
             if (candidate.dispatch !== 'static' && candidate.dispatch !== 'instance')
                 invalidAST();
@@ -49,7 +51,18 @@ export function normalizePathAST(input) {
                     invalidAST();
                 }
             }
-            steps.push({ kind: 'method', dispatch: candidate.dispatch, name: candidate.name });
+            if (candidate.dispatch === 'instance') {
+                if (!ClassKey.is(candidate.class))
+                    invalidAST();
+                steps.push({
+                    kind: 'method',
+                    dispatch: 'instance',
+                    class: ClassKey(candidate.class),
+                    name: candidate.name,
+                });
+            }
+            else
+                steps.push({ kind: 'method', dispatch: 'static', name: candidate.name });
             continue;
         }
         if (candidate.kind === 'traverse') {
@@ -111,11 +124,12 @@ function parseSteps(input, start, anchorKind) {
     let cursor = start;
     while (cursor < input.length) {
         if (input.startsWith('::', cursor)) {
-            const name = input.slice(cursor + 2);
-            if (!patterns.memberName.test(name)) {
-                throw pathError(input, 'PATH_INVALID_METHOD', 'Invalid instance Method name.', cursor + 2);
+            const key = input.slice(cursor + 2);
+            if (!MethodKey.is(key)) {
+                throw pathError(input, 'PATH_INVALID_METHOD', 'Instance Method requires a complete domain-qualified Method key.', cursor + 2);
             }
-            steps.push({ kind: 'method', dispatch: 'instance', name });
+            const { owner, name } = MethodKey.address(key);
+            steps.push({ kind: 'method', dispatch: 'instance', class: ClassKey.of(owner), name });
             cursor = input.length;
             continue;
         }
@@ -234,7 +248,8 @@ function serializeNormalizedPathAST(ast) {
             output += `:${step.projection.kind}.${step.projection.name}`;
         }
         else if (step.kind === 'method') {
-            output += `${step.dispatch === 'instance' ? '::' : ':'}${step.name}`;
+            output +=
+                step.dispatch === 'instance' ? `::${step.class}.method.${step.name}` : `:${step.name}`;
         }
         else {
             output += `${step.direction === 'in' ? '<~' : '~'}"${step.class}"`;

package/dist/schema/authority/operation-node.d.ts

@@ -27,6 +27,8 @@ export declare const Operation: builder.NodeClass<{
         };
         readonly methods: Readonly<Record<never, never>>;
     }, builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "name", unknown, undefined>, never, never>, undefined>;
+    readonly abstractInstanceMethods: never;
+    readonly abstractStaticMethods: never;
     readonly effectiveInstanceMethods: never;
     readonly effectiveStaticMethods: never;
 }>;

package/dist/schema/authority/policy.d.ts

@@ -27,6 +27,8 @@ export declare const Policy: builder.NodeClass<{
         };
         readonly methods: Readonly<Record<never, never>>;
     }, builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", unknown, never>, never, never>, never>;
+    readonly abstractInstanceMethods: never;
+    readonly abstractStaticMethods: never;
     readonly effectiveInstanceMethods: never;
     readonly effectiveStaticMethods: never;
 }>;

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

@@ -24,12 +24,16 @@ export declare const Function: builder.NodeClass<{
         readonly auth: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "auth", "self", undefined>;
         readonly policy: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "policy", "self", never>;
         readonly static: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "static", "self", never>;
-        readonly inheritance: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "inheritance", "self", never>;
+        readonly abstract: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "abstract", "self", never>;
     };
     readonly methods: Readonly<{
         admit: builder.Method<builder.CallableProjection<{
             call: {
-                target: string;
+                target: string | {
+                    callable: string;
+                    instance?: string | undefined;
+                    revision?: string | undefined;
+                };
                 input: unknown;
             };
             credential?: string | undefined;
@@ -39,7 +43,7 @@ export declare const Function: builder.NodeClass<{
                 callable: string;
                 receiver?: string | undefined;
             };
-        }, "authenticated", true, "sealed">>;
+        }, "authenticated", true, false>>;
     }>;
     readonly effectiveProperties: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", builder.ClassOwnerProjection<"node", {
         readonly abstract: true;
@@ -48,11 +52,17 @@ export declare const Function: builder.NodeClass<{
             readonly description: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", "self", never>;
         };
         readonly methods: Readonly<Record<never, never>>;
-    }, builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", unknown, never>, never, never>, never> | (builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "auth", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "inheritance", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "input", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "kind", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "output", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "policy", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "static", "self", never>);
+    }, builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", unknown, never>, never, never>, never> | (builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "abstract", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "auth", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "input", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "kind", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "output", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "policy", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "static", "self", never>);
+    readonly abstractInstanceMethods: never;
+    readonly abstractStaticMethods: never;
     readonly effectiveInstanceMethods: never;
     readonly effectiveStaticMethods: builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
         call: {
-            target: string;
+            target: string | {
+                callable: string;
+                instance?: string | undefined;
+                revision?: string | undefined;
+            };
             input: unknown;
         };
         credential?: string | undefined;
@@ -62,5 +72,5 @@ export declare const Function: builder.NodeClass<{
             callable: string;
             receiver?: string | undefined;
         };
-    }, "authenticated", true, "sealed">>, "admit", "self">;
+    }, "authenticated", true, false>>, "admit", "self">;
 }>;

package/dist/schema/callables/function.js

@@ -12,7 +12,7 @@ export const Function = nodeClass({
         auth: { enum: ['anonymous', 'authenticated', 'authorized'] },
         policy: property({ type: 'object' }, { required: false }),
         static: property({ type: 'boolean' }, { required: false }),
-        inheritance: property({ enum: ['abstract', 'default', 'sealed'] }, { required: false }),
+        abstract: property({ type: 'boolean' }, { required: false }),
     },
     methods: FunctionMethods,
 });

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

@@ -51,7 +51,7 @@ export declare const View: builder.NodeClass<{
                     revision: string;
                 }[];
             };
-        }, "authorized", true, "sealed">>;
+        }, "authorized", true, false>>;
     }>;
     readonly effectiveProperties: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", builder.ClassOwnerProjection<"node", {
         readonly abstract: true;
@@ -61,6 +61,8 @@ export declare const View: builder.NodeClass<{
         };
         readonly methods: Readonly<Record<never, never>>;
     }, builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "description", unknown, never>, never, never>, never>;
+    readonly abstractInstanceMethods: never;
+    readonly abstractStaticMethods: never;
     readonly effectiveInstanceMethods: never;
     readonly effectiveStaticMethods: builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
         target: string;
@@ -94,5 +96,5 @@ export declare const View: builder.NodeClass<{
                 revision: string;
             }[];
         };
-    }, "authorized", true, "sealed">>, "resolve", "self">;
+    }, "authorized", true, false>>, "resolve", "self">;
 }>;

package/dist/schema/definitions/class.d.ts

@@ -51,6 +51,8 @@ export declare const Class: builder.NodeClass<{
         };
         readonly methods: Readonly<Record<never, never>>;
     }, builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "icon", unknown, never>, never, never>, never> | (builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "abstract", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "kind", "self", undefined>);
+    readonly abstractInstanceMethods: never;
+    readonly abstractStaticMethods: never;
     readonly effectiveInstanceMethods: never;
     readonly effectiveStaticMethods: never;
 }>;