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

package/dist/invocation/index.d.ts

@@ -15,6 +15,6 @@ export { decodeResponse, type ErrorResponse, type Response, type ResponseContext
 export { SCHEMA_REVISION_MISMATCH, SERVICE_CANDIDATE_INVALID, SERVICE_TRUST_REQUIRED, SERVICE_UNAVAILABLE, serviceErrorOf, type SchemaRevisionMismatchDetails, type SchemaRevisionMismatchReason, type ServiceCandidateInvalidDetails, type ServiceCandidateInvalidReason, type ServiceErrorPayload, type ServiceReason, type ServiceTrustRequiredDetails, type ServiceTrustRequiredReason, type ServiceUnavailableDetails, type ServiceUnavailableReason, } from './service-reason.js';
 export { decodeStale, stale, type Stale } from './stale-route.js';
 export { decodeStreamFrame, type StreamEndFrame, type StreamErrorFrame, type StreamFrame, type StreamItemFrame, type StreamStartFrame, } from './stream.js';
-export { acceptCall, type Call } from './target.js';
+export { Target, targetPath, acceptCall, type Call } from './target.js';
 export { VERSION, type Version } from './version.js';
 export * as websocket from './websocket/index.js';

package/dist/invocation/index.js

@@ -15,6 +15,6 @@ export { decodeResponse, } from './response.js';
 export { SCHEMA_REVISION_MISMATCH, SERVICE_CANDIDATE_INVALID, SERVICE_TRUST_REQUIRED, SERVICE_UNAVAILABLE, serviceErrorOf, } from './service-reason.js';
 export { decodeStale, stale } from './stale-route.js';
 export { decodeStreamFrame, } from './stream.js';
-export { acceptCall } from './target.js';
+export { Target, targetPath, acceptCall } from './target.js';
 export { VERSION } from './version.js';
 export * as websocket from './websocket/index.js';

package/dist/invocation/target.d.ts

@@ -1,3 +1,3 @@
-import type { Call } from '@astrale-os/kernel-core/callable';
-export type { Call } from '@astrale-os/kernel-core/callable';
+import { type Call } from '@astrale-os/kernel-core/callable';
+export { Target, targetPath, type Call } from '@astrale-os/kernel-core/callable';
 export declare function acceptCall(input: unknown): Call;

package/dist/invocation/target.js

@@ -1,11 +1,26 @@
-import { exactFields, nodePath, portableObject, required } from './admission.js';
+import { Target } from '@astrale-os/kernel-core/callable';
+import { PathError } from '@astrale-os/kernel-core/path';
+import { exactFields, invalid, nodePath, portableObject, required } from './admission.js';
+export { Target, targetPath } from '@astrale-os/kernel-core/callable';
 const CALL_FIELDS = new Set(['target', 'input']);
 export function acceptCall(input) {
     const object = portableObject(input, 'call');
     exactFields(object, CALL_FIELDS, 'call');
     required(object, ['target', 'input'], 'call');
     return Object.freeze({
-        target: nodePath(object.target, 'call.target'),
+        target: acceptTarget(object.target),
         input: object.input,
     });
 }
+function acceptTarget(input) {
+    if (typeof input === 'string')
+        return nodePath(input, 'call.target');
+    try {
+        return Target(input);
+    }
+    catch (cause) {
+        if (cause instanceof TypeError || cause instanceof PathError)
+            return invalid('call.target must be a canonical NodePath or declaration Target');
+        throw cause;
+    }
+}

package/dist/publication/bundle-admission.js

@@ -57,7 +57,7 @@ function addClassMethods(result, origin, definitions) {
         if (declaration.kind !== 'node')
             continue;
         for (const [name, method] of Object.entries(declaration.methods)) {
-            if (method.inheritance === 'abstract')
+            if (method.abstract === true)
                 continue;
             result.add(MethodKey.of({ origin, kind: 'class', name: owner }, name));
         }

package/dist/publication/requirements.js

@@ -119,9 +119,11 @@ export function validateRequirements(root, closure, requirements) {
             fail('PUBLICATION_INVALID', 'Core capability subject must name one local Core Identity.');
         }
         for (const callable of requirement.functions ?? []) {
-            const dependency = capabilityOwner(root, dependencies, callable, 'Function');
-            if (!hasCallable(dependency, callable)) {
-                fail('PUBLICATION_INVALID', 'Core capability Function requirement names an unknown dependency callable.');
+            const owner = Key.origin(callable) === root.origin
+                ? root
+                : capabilityOwner(root, dependencies, callable, 'Function');
+            if (!hasCallable(owner, callable)) {
+                fail('PUBLICATION_INVALID', 'Core capability Function requirement names an unknown or non-executable callable.');
             }
         }
         for (const classRequirement of requirement.classes ?? []) {
@@ -280,5 +282,5 @@ function hasCallable(dependency, callable) {
         return dependency.functions[coordinate.name] !== undefined;
     const declaration = dependency.classes[coordinate.owner.name];
     const method = declaration?.kind === 'node' ? declaration.methods[coordinate.name] : undefined;
-    return method !== undefined && method.inheritance !== 'abstract';
+    return method !== undefined && method.abstract !== true;
 }

package/dist/routes/compiler.js

@@ -11,8 +11,8 @@ export function compile(input) {
     const authored = input.routes.map((entry) => admitRouteDeclaration(entry, input.domain.origin));
     const entries = authored.map((declaration) => {
         const meaning = input.domain.callable(declaration.callable);
-        if (meaning === undefined) {
-            fail('NATIVE_ROUTE_BINDING_INVALID', `Unknown callable ${declaration.callable}.`);
+        if (meaning === undefined || (isMethod(meaning) && meaning.abstract)) {
+            fail('NATIVE_ROUTE_BINDING_INVALID', `Unavailable callable ${declaration.callable}.`);
         }
         const href = placePath(declaration.path, 'https://routes.invalid');
         const route = { ...declaration, href };

package/dist/routes/decode.js

@@ -1,5 +1,4 @@
-import { NodePath, Path } from '@astrale-os/kernel-core/path';
-import { callableAddress } from '@astrale-os/kernel-dsl/v1/addressing';
+import { NodePath } from '@astrale-os/kernel-core/path';
 import * as portable from '@astrale-os/kernel-dsl/value';
 import { readCredential, specificHeaderWires, withoutCredentialHeaders } from './credential.js';
 import { fail, invalidRequest } from './error.js';
@@ -112,16 +111,11 @@ export function decode(entry, request, domain, served) {
         }
         throw cause;
     }
-    const coordinate = callableAddress(entry.callable);
-    const target = coordinate.kind === 'method'
-        ? receiver === undefined
-            ? Path.staticMethod(Path.project(coordinate.owner), coordinate.name).raw
-            : Path.instanceMethod(Path.from(receiver), coordinate.name).raw
-        : Path.project({
-            origin: coordinate.origin,
-            kind: 'function',
-            name: coordinate.name,
-        }).raw;
+    const target = Object.freeze({
+        callable: entry.callable,
+        revision: domain.revision,
+        ...(receiver === undefined ? {} : { instance: receiver }),
+    });
     return Object.freeze({
         call: Object.freeze({ target, input }),
         ...(credential === undefined ? {} : { credential }),

package/dist/routes/encode.js

@@ -1,3 +1,4 @@
+import { targetPath } from '@astrale-os/kernel-core/callable';
 import { Path } from '@astrale-os/kernel-core/path';
 import { callableAddress } from '@astrale-os/kernel-dsl/v1/addressing';
 import * as portable from '@astrale-os/kernel-dsl/value';
@@ -9,15 +10,20 @@ import { asObject, encodeScalar, scalar } from './scalar.js';
 import { requiresReceiver } from './target.js';
 import { authorityEnd, encodeTemplate, PLACEHOLDER } from './template.js';
 export function encode(entry, invocation, domain) {
+    if (typeof invocation.call.target !== 'string' &&
+        invocation.call.target.revision !== undefined &&
+        invocation.call.target.revision !== domain.revision) {
+        invalidRequest('Invocation Target revision does not match the selected route Domain.');
+    }
     const input = asObject(invocation.call.input);
-    const target = Path.from(invocation.call.target);
+    const target = Path.from(targetPath(invocation.call.target));
     const needsReceiver = requiresReceiver(entry);
     const coordinate = callableAddress(entry.callable);
     const methodName = coordinate.kind === 'method' ? coordinate.name : undefined;
     const receiver = needsReceiver ? instanceSource(target, methodName) : undefined;
     const source = receiver?.raw;
     const expected = needsReceiver
-        ? Path.instanceMethod(receiver, methodName).raw
+        ? Path.instanceMethod(receiver, entry.callable).raw
         : coordinate.kind === 'method'
             ? Path.staticMethod(Path.project(coordinate.owner), methodName).raw
             : Path.project({

package/dist/routes/evidence.js

@@ -16,6 +16,7 @@ export function verifyTable(table, deployed, domain) {
             ((entry.target.kind === 'function' && !isMethod(meaning)) ||
                 (entry.target.kind === 'method' &&
                     isMethod(meaning) &&
+                    !meaning.abstract &&
                     entry.target.dispatch === (meaning.static ? 'static' : 'instance')));
         if (!targetMatches || meaning.auth !== entry.auth || meaning.output.mode !== entry.output) {
             fail('NATIVE_ROUTE_BINDING_INVALID', `Route ${entry.name} differs from Domain meaning.`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-protocol",
-  "version": "0.5.0-beta.46",
+  "version": "0.5.0-beta.48",
   "description": "Portable Astrale invocation, publication, installation, routing, and issuer protocols",
   "license": "Apache-2.0",
   "repository": {
@@ -137,8 +137,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@astrale-os/kernel-core": "0.9.0-beta.42",
-    "@astrale-os/kernel-dsl": "0.2.0-beta.30",
+    "@astrale-os/kernel-core": "0.9.0-beta.44",
+    "@astrale-os/kernel-dsl": "0.2.0-beta.32",
     "@noble/hashes": "2.3.0"
   },
   "devDependencies": {