@astrale-os/kernel-dsl 0.2.0-beta.32 → 0.2.0-beta.34

package/dist/v1/schema/index.d.ts

@@ -12,7 +12,7 @@ export { acceptDomainSchema as accept } from './admission/accept.js';
 export { decodeDomainSchema as decode, encodeDomainSchema as encode, serializeDomainSchema as serialize, } from './codec/schema.js';
 export { revisionOfDomainSchema as revision } from './canonical/revision.js';
 export { compareDependencyMeaning, compareMemberMeaning } from './compatibility/meaning.js';
-export type { DependencyMeaningChange, DependencyMeaningChangeKind, DependencyMeaningComparison, MeaningFingerprint, } from './compatibility/meaning.js';
+export type { DependencyMeaningChange, DependencyMeaningChangeKind, DependencyMeaningComparison, DependencyMeaningLevel, MeaningFingerprint, } from './compatibility/meaning.js';
 export { header } from './codec/header.js';
 export { DOMAIN_FORMAT as FORMAT, DOMAIN_VERSION as VERSION } from './model/format.js';
 export { compile, load } from '../compiled/index.js';

package/dist/v1/schema/resolution/origins.d.ts

@@ -4,11 +4,22 @@ import type { ClassDefinition } from '../../language/class/model/class.js';
 import type { PolicyDefinition } from '../../language/policy/model/policy.js';
 import type { JsonSchema } from '../../language/value/model/schema.js';
 import type { DomainSchemaIR } from '../model/schema.js';
+/**
+ * Where one schema references a Definition. `extends` and `core` mean the schema inherits from or
+ * instantiates the Definition; every other site only refers to it.
+ */
+export type ReferenceSite = 'extends' | 'endpoint' | 'value' | 'policy' | 'view' | 'core';
+export type ReferenceCollector = (ref: DefinitionRef, site: ReferenceSite) => void;
 /** Collect only semantic refs, never strings or objects embedded as JSON data. */
 export declare function collectUsedForeignOrigins(schema: DomainSchemaIR): ReadonlySet<string>;
 /** Complete structured references in one schema, in canonical order. */
 export declare function collectDomainDefinitionRefs(schema: DomainSchemaIR): readonly DefinitionRef[];
-export declare function collectClassRefs(declaration: ClassDefinition, add: (ref: DefinitionRef) => void): void;
-export declare function collectCallableRefs(declaration: FunctionDefinition | MethodDefinition, add: (ref: DefinitionRef) => void): void;
-export declare function collectPolicyDefinitionRefs(declaration: PolicyDefinition, add: (ref: DefinitionRef) => void): void;
-export declare function collectValueDefinitionRefs(schema: JsonSchema, add: (ref: DefinitionRef) => void): void;
+export declare function collectCoreRefs(schema: DomainSchemaIR, add: ReferenceCollector): void;
+export declare function collectClassRefs(declaration: ClassDefinition, add: ReferenceCollector): void;
+export declare function collectClassPolicyRefs(declaration: ClassDefinition, add: ReferenceCollector): void;
+export declare function collectEndpointRefs(declaration: Extract<ClassDefinition, {
+    readonly kind: 'edge';
+}>, add: ReferenceCollector): void;
+export declare function collectCallableRefs(declaration: FunctionDefinition | MethodDefinition, add: ReferenceCollector): void;
+export declare function collectPolicyDefinitionRefs(declaration: PolicyDefinition, add: ReferenceCollector): void;
+export declare function collectValueDefinitionRefs(schema: JsonSchema, add: ReferenceCollector): void;

package/dist/v1/schema/resolution/origins.js

@@ -24,39 +24,46 @@ export function collectDomainDefinitionRefs(schema) {
         collectPolicyDefinitionRefs(declaration, add);
     }
     for (const declaration of Object.values(schema.views)) {
-        if (declaration.target.kind === 'definition')
-            declaration.target.definitions.forEach(add);
+        if (declaration.target.kind === 'definition') {
+            declaration.target.definitions.forEach((ref) => add(ref, 'view'));
+        }
     }
+    collectCoreRefs(schema, add);
+    return Object.freeze([...result.values()].sort(compareDefinitionRefs));
+}
+export function collectCoreRefs(schema, add) {
     for (const node of Object.values(schema.core.nodes))
-        add(node.class);
+        add(node.class, 'core');
     for (const edge of schema.core.edges) {
-        add(edge.class);
+        add(edge.class, 'core');
         if (edge.source.kind !== 'domain')
-            add(edge.source);
+            add(edge.source, 'core');
         if (edge.target.kind !== 'domain')
-            add(edge.target);
+            add(edge.target, 'core');
     }
-    return Object.freeze([...result.values()].sort(compareDefinitionRefs));
 }
 export function collectClassRefs(declaration, add) {
-    declaration.extends.forEach(add);
+    declaration.extends.forEach((ref) => add(ref, 'extends'));
     Object.values(declaration.properties).forEach((property) => collectValueDefinitionRefs(property.schema, add));
-    if (declaration.policies.read !== undefined)
-        add(declaration.policies.read);
-    if (declaration.policies.traverse !== undefined)
-        add(declaration.policies.traverse);
+    collectClassPolicyRefs(declaration, add);
     if (declaration.kind === 'edge') {
         collectEndpointRefs(declaration, add);
         return;
     }
     Object.values(declaration.methods).forEach((method) => collectCallableRefs(method, add));
 }
-function collectEndpointRefs(declaration, add) {
+export function collectClassPolicyRefs(declaration, add) {
+    if (declaration.policies.read !== undefined)
+        add(declaration.policies.read, 'policy');
+    if (declaration.policies.traverse !== undefined)
+        add(declaration.policies.traverse, 'policy');
+}
+export function collectEndpointRefs(declaration, add) {
     const endpoints = declaration.orientation === 'directed'
         ? [declaration.endpoints.source, declaration.endpoints.target]
         : declaration.endpoints;
-    endpoints[0].accepts.forEach(add);
-    endpoints[1].accepts.forEach(add);
+    endpoints[0].accepts.forEach((ref) => add(ref, 'endpoint'));
+    endpoints[1].accepts.forEach((ref) => add(ref, 'endpoint'));
 }
 export function collectCallableRefs(declaration, add) {
     collectValueDefinitionRefs(declaration.input, add);
@@ -76,27 +83,27 @@ function collectPolicyExpressionRefs(expression, add) {
         return;
     }
     const refs = 'allOf' in expression ? expression.allOf : expression.anyOf;
-    refs.forEach(add);
+    refs.forEach((ref) => add(ref, 'policy'));
 }
 function collectPolicyPatternRefs(expression, add) {
     if ('sameNode' in expression) {
         for (const term of [expression.sameNode.left, expression.sameNode.right])
             if (term.kind === 'ref')
-                add(term.ref.kind === 'method' ? term.ref.owner : term.ref);
+                add(term.ref.kind === 'method' ? term.ref.owner : term.ref, 'policy');
         return;
     }
     if ('source' in expression) {
         for (const term of [expression.source, expression.target])
             if (term.kind === 'ref')
-                add(term.ref.kind === 'method' ? term.ref.owner : term.ref);
-        add(expression.class);
+                add(term.ref.kind === 'method' ? term.ref.owner : term.ref, 'policy');
+        add(expression.class, 'policy');
         return;
     }
     if ('exists' in expression) {
         expression.exists.nodes.forEach((node) => {
             const ref = policyVariableClass(node);
             if (ref !== undefined)
-                add(ref);
+                add(ref, 'policy');
         });
         collectPolicyPatternRefs(expression.exists.where, add);
         return;
@@ -108,15 +115,15 @@ function collectPolicyCheckRefs(expression, add) {
     if ('sameNode' in expression) {
         for (const term of [expression.sameNode.left, expression.sameNode.right])
             if (term.kind === 'ref')
-                add(term.ref.kind === 'method' ? term.ref.owner : term.ref);
+                add(term.ref.kind === 'method' ? term.ref.owner : term.ref, 'policy');
         return;
     }
     if ('check' in expression) {
-        add(expression.check);
+        add(expression.check, 'policy');
         if (expression.object.kind === 'ref')
             add(expression.object.ref.kind === 'method'
                 ? expression.object.ref.owner
-                : expression.object.ref);
+                : expression.object.ref, 'policy');
         return;
     }
     const children = 'allOf' in expression ? expression.allOf : expression.anyOf;
@@ -134,7 +141,7 @@ export function collectValueDefinitionRefs(schema, add) {
                 typeof candidate.origin === 'string' &&
                 typeof candidate.kind === 'string' &&
                 typeof candidate.name === 'string') {
-                add(candidate);
+                add(candidate, 'value');
             }
         }
     });

package/dist/v1/schema/validation/class.js

@@ -1,5 +1,6 @@
 import { Key } from '../../addressing/key.js';
 import { definitionRefIndex } from '../../addressing/ordering.js';
+import { isMethodExecutable } from '../../language/callable/executable.js';
 import { admitStateTopology } from '../../language/state/topology.js';
 import { classifyOrdering } from '../../language/value/ordering.js';
 import { diagnostic } from '../diagnostic.js';
@@ -71,7 +72,7 @@ function validateFacet(environment, declaration, pointer, diagnostics) {
         return;
     for (const [name, method] of Object.entries(declaration.methods)) {
         const methodPointer = `${pointer}/methods/${escapePointer(name)}`;
-        if (method.abstract === true && method.policy !== undefined) {
+        if (!isMethodExecutable(declaration, method) && method.policy !== undefined) {
             diagnostics.push(diagnostic('DV_METHOD_ABSTRACT', `${methodPointer}/policy`, 'Abstract Methods cannot have a Policy.'));
         }
     }

package/dist/v1/schema/validation/domain.structure.js

@@ -190,14 +190,6 @@ const methodDeclarationSchema = strictObject({
     static: boolean(),
     abstract: boolean(),
 }).superRefine((method, context) => {
-    if (method.abstract === true && method.policy !== undefined) {
-        context.addIssue({
-            code: 'custom',
-            path: ['policy'],
-            message: 'An abstract method cannot declare a policy.',
-            params: { structureCode: 'STRUCTURE_ABSTRACT_POLICY' },
-        });
-    }
     if (method.auth !== 'authorized' && method.policy !== undefined) {
         context.addIssue({
             code: 'custom',

package/dist/v1/schema/validation/policy/objects.js

@@ -1,4 +1,5 @@
 import { definitionRefIndex } from '../../../addressing/ordering.js';
+import { isMethodExecutable } from '../../../language/callable/executable.js';
 import { policyObjectKey, policyObjectOrigin } from '../../../language/index.js';
 const KERNEL_ORIGIN = 'kernel.astrale.ai';
 const PROJECTION_CLASS = nodeClassRef('Class');
@@ -26,7 +27,7 @@ export function referenceContracts(validation, ref, pointer) {
         case 'method': {
             const declaringClass = owner.classes[ref.owner.name];
             const method = declaringClass?.kind === 'node' ? declaringClass.methods[ref.name] : undefined;
-            return method === undefined || method.abstract
+            return method === undefined || !isMethodExecutable(declaringClass, method)
                 ? invalidPolicyObjectRef(validation, ref, pointer)
                 : [{ kind: 'exact', ref: PROJECTION_FUNCTION }];
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-dsl",
-  "version": "0.2.0-beta.32",
+  "version": "0.2.0-beta.34",
   "description": "Astrale Kernel DSL - Schema authoring, inference, and IR serialization",
   "license": "Apache-2.0",
   "repository": {
@@ -105,7 +105,7 @@
     "generate:value-schema-validator": "node scripts/generate-value-schema-meta-validator.mjs",
     "layout:check": "node scripts/check-layout.mjs",
     "spec:typecheck": "tsgo --noEmit -p tsconfig.spec.json",
-    "typecheck": "tsgo --noEmit && tsgo --noEmit -p tsconfig.types.json",
+    "typecheck": "tsgo --noEmit && tsgo --noEmit -p tsconfig.types.json && tsgo -p tsconfig.workers.json",
     "test": "pnpm run conformance && pnpm run layout:check && vitest run",
     "test:file": "vitest run",
     "test:semantic-lock": "pnpm run conformance && pnpm run layout:check && vitest run",