@astrale-os/kernel-core 0.9.0-beta.42 → 0.9.0-beta.44

package/dist/schema/identity/identity.d.ts

@@ -38,13 +38,14 @@ export declare const Identity: builder.NodeClass<{
     };
     readonly methods: Readonly<{
         delegate: builder.Method<builder.CallableProjection<{
+            principal: string;
             audience: string;
             ttlSeconds: number;
             attenuation: unknown;
         }, {
             readonly mode: 'value';
             readonly value: string;
-        }, "authenticated", false, "default">>;
+        }, "authenticated", true, false>>;
         can: builder.Method<builder.CallableProjection<{
             policy: string;
             object: string;
@@ -53,7 +54,7 @@ export declare const Identity: builder.NodeClass<{
             readonly value: {
                 allowed: boolean;
             };
-        }, "authenticated", true, "default">>;
+        }, "authenticated", true, false>>;
         whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
             readonly mode: 'value';
             readonly value: {
@@ -74,7 +75,7 @@ export declare const Identity: builder.NodeClass<{
                     op: "exists";
                 })[];
             };
-        }, "authenticated", true, "default">>;
+        }, "authenticated", true, false>>;
         whois: builder.Method<builder.CallableProjection<{
             iss: string;
             sub: string;
@@ -98,7 +99,7 @@ export declare const Identity: builder.NodeClass<{
                     op: "exists";
                 })[];
             } | null;
-        }, "authorized", true, "default">>;
+        }, "authorized", true, false>>;
         mint: builder.Method<builder.CallableProjection<{
             audience?: string | undefined;
             ttlSeconds: number;
@@ -106,7 +107,7 @@ export declare const Identity: builder.NodeClass<{
         }, {
             readonly mode: 'value';
             readonly value: string;
-        }, "authenticated", true, "default">>;
+        }, "authenticated", true, false>>;
     }>;
     readonly effectiveProperties: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", "self", never> | builder.AuthoredPropertyProjection<({
         claim: string;
@@ -131,14 +132,9 @@ export declare const Identity: builder.NodeClass<{
         claim: string;
         op: "exists";
     })[], false, "requiredClaims", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", "self", never>;
-    readonly effectiveInstanceMethods: builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
-        audience: string;
-        ttlSeconds: number;
-        attenuation: unknown;
-    }, {
-        readonly mode: 'value';
-        readonly value: string;
-    }, "authenticated", false, "default">>, "delegate", "self">;
+    readonly abstractInstanceMethods: never;
+    readonly abstractStaticMethods: never;
+    readonly effectiveInstanceMethods: never;
     readonly effectiveStaticMethods: builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
         readonly mode: 'value';
         readonly value: {
@@ -159,14 +155,22 @@ export declare const Identity: builder.NodeClass<{
                 op: "exists";
             })[];
         };
-    }, "authenticated", true, "default">>, "whoami", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+    }, "authenticated", true, false>>, "whoami", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
         audience?: string | undefined;
         ttlSeconds: number;
         grant?: unknown;
     }, {
         readonly mode: 'value';
         readonly value: string;
-    }, "authenticated", true, "default">>, "mint", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+    }, "authenticated", true, false>>, "mint", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+        principal: string;
+        audience: string;
+        ttlSeconds: number;
+        attenuation: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: string;
+    }, "authenticated", true, false>>, "delegate", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
         policy: string;
         object: string;
     }, {
@@ -174,7 +178,7 @@ export declare const Identity: builder.NodeClass<{
         readonly value: {
             allowed: boolean;
         };
-    }, "authenticated", true, "default">>, "can", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
+    }, "authenticated", true, false>>, "can", "self"> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
         iss: string;
         sub: string;
     }, {
@@ -197,5 +201,5 @@ export declare const Identity: builder.NodeClass<{
                 op: "exists";
             })[];
         } | null;
-    }, "authorized", true, "default">>, "whois", "self">;
+    }, "authorized", true, false>>, "whois", "self">;
 }>;

package/dist/schema/kernel/projection/callables.js

@@ -12,8 +12,7 @@ export function projectedCallables(domain) {
         if (!('methods' in definition) || definition.kind !== 'node')
             continue;
         for (const method of [...definition.methods, ...definition.static.methods]) {
-            if (method.owner.ref.origin !== domain.origin ||
-                method.definition.inheritance === 'abstract') {
+            if (method.owner.ref.origin !== domain.origin || method.definition.abstract === true) {
                 continue;
             }
             result.set(projectedMethodPath(domain, method), method.key);
@@ -29,5 +28,5 @@ export function projectedMethodPath(domain, method) {
     const owner = Path.project(method.owner.ref);
     return (method.definition.static
         ? Path.staticMethod(owner, method.name)
-        : Path.instanceMethod(owner, method.name)).raw;
+        : Path.instanceMethod(owner, method.key)).raw;
 }

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

@@ -1,6 +1,6 @@
 export { project } from './project.js';
 export { compile } from './compile.js';
-export { projectedCallables } from './callables.js';
+export { projectedCallables, projectedMethodPath } from './callables.js';
 export { ProjectionError } from './diagnostics.js';
 export type { ProjectionErrorCode } from './diagnostics.js';
 export type { CoreProjection, Projection, ProjectionPart } from './types.js';

package/dist/schema/kernel/projection/index.js

@@ -1,4 +1,4 @@
 export { project } from './project.js';
 export { compile } from './compile.js';
-export { projectedCallables } from './callables.js';
+export { projectedCallables, projectedMethodPath } from './callables.js';
 export { ProjectionError } from './diagnostics.js';

package/dist/schema/kernel/projection/keys.js

@@ -11,8 +11,7 @@ export function managedKeys(domain) {
         if (!('methods' in definition) || definition.kind !== 'node')
             continue;
         for (const method of [...definition.methods, ...definition.static.methods]) {
-            if (method.owner.ref.origin !== domain.origin ||
-                method.definition.inheritance === 'abstract') {
+            if (method.owner.ref.origin !== domain.origin || method.definition.abstract === true) {
                 continue;
             }
             add(keys, projectedMethodPath(domain, method));

package/dist/schema/kernel/projection/path.js

@@ -32,7 +32,7 @@ function applyStep(current, step, context) {
         case 'method':
             return step.dispatch === 'static'
                 ? directMethods(current, step.name, true, context)
-                : instanceMethods(current, step.name, context);
+                : instanceMethods(current.filter((node) => node.class === step.class), step.name, context);
         case 'traverse':
             return traverse(current, step, context);
     }
@@ -63,7 +63,7 @@ function directMethods(owners, name, isStatic, context) {
 function instanceMethods(instances, name, context) {
     return distinctNodes(instances.flatMap((instance) => {
         const owner = resolveClassProjection(instance.class, context);
-        return owner.length === 0 ? [] : effectiveMethods(owner, name, context);
+        return owner.length === 0 ? [] : directMethods(owner, name, false, context);
     }));
 }
 function resolveClassProjection(key, context) {
@@ -73,33 +73,6 @@ function resolveClassProjection(key, context) {
         .filter((node) => node.props[K.classes.Domain.properties.origin.key] === ClassKey.ref(key).origin);
     return domainMembers(domains, `class.${ClassKey.ref(key).name}`, context);
 }
-/** Select the nearest declared Method in the valid Definition inheritance graph. */
-function effectiveMethods(roots, name, context) {
-    let level = distinctNodes(roots);
-    const visited = new Set();
-    while (level.length > 0) {
-        const fresh = level.filter((node) => !visited.has(node.id));
-        for (const node of fresh)
-            visited.add(node.id);
-        if (fresh.length === 0)
-            return [];
-        const methods = directMethods(fresh, name, false, context);
-        if (methods.length > 0)
-            return methods;
-        level = parentDefinitions(fresh, context);
-    }
-    return [];
-}
-function parentDefinitions(definitions, context) {
-    const ids = new Set(definitions.map((node) => node.id));
-    const relations = [K.classes.extends];
-    return distinctNodes(relations.flatMap((relation) => edgesOf(relation, context).flatMap((edge) => {
-        if (!ids.has(edge.source))
-            return [];
-        const parent = context.nodes.byId(edge.target);
-        return parent === undefined ? [] : [parent];
-    })));
-}
 function traverse(current, step, context) {
     const currentIds = new Set(current.map((node) => node.id));
     const edgeClass = step.class;

package/dist/schema/kernel/projection/project.js

@@ -45,8 +45,7 @@ export function project(domain) {
     const methods = new Map();
     for (const definition of Object.values(domain.classes)) {
         for (const method of [...definition.methods, ...definition.static.methods]) {
-            if (method.owner.ref.origin === domain.origin &&
-                method.definition.inheritance !== 'abstract') {
+            if (method.owner.ref.origin === domain.origin && method.definition.abstract !== true) {
                 methods.set(method.key, method);
             }
         }
@@ -233,7 +232,7 @@ function callablePropertiesFor(declaration) {
         ...(method
             ? {
                 [K.classes.Function.self.properties.static.key]: declaration.static,
-                [K.classes.Function.self.properties.inheritance.key]: declaration.inheritance,
+                [K.classes.Function.self.properties.abstract.key]: declaration.abstract,
             }
             : {}),
     });