@astrale-os/kernel-dsl 0.2.0-beta.27 → 0.2.0-beta.28

package/dist/v1/builder/callable/authoring.d.ts

@@ -91,7 +91,7 @@ export type ProjectionOfCallable<Value extends Function | Method> = Value extend
 /** Internal lowering access; Callable authoring handles expose no public configuration object. */
 export declare function callableConfiguration(value: Function | Method): CallableInput;
 export type PolicyObjectAuthoring = Class | Function | Policy | View | CoreNode;
-export type PolicyObjectInput = Lazy<PolicyObjectAuthoring>;
+export type PolicyObjectInput = Lazy<PolicyObjectAuthoring | PolicyObjectRef>;
 export declare function func<const Config extends FunctionInput, Input = ValueInputOf<Config['input']>, Output = CallableOutputOf<Config['output']>, Auth extends FunctionAuth = Config['auth']>(config: Config): Function<CallableProjection<Input, Output, Auth, false, 'default'>>;
 export declare function method<const Config extends MethodInput, Input = ValueInputOf<Config['input']>, Output = CallableOutputOf<Config['output']>, Auth extends FunctionAuth = Config['auth'], Static extends boolean = Config extends {
     readonly static: true;

package/dist/v1/builder/lowering/schema/context.js

@@ -50,22 +50,22 @@ export class BuilderContext {
         this.capturePolicyObject(value, ref);
     }
     capturePolicy(value, ref, pointer) {
-        this.ownership.capture(value, `${ref.origin}:policy.${ref.name}`, pointer);
+        this.ownership.captureDefinition(value, ref, pointer);
         this.policies.set(value, ref);
         this.capturePolicyObject(value, ref);
     }
     captureCoreNode(value, slug, pointer) {
-        this.ownership.capture(value, `${this.origin}:core.${slug}`, pointer);
         const ref = { origin: this.origin, kind: 'core', name: slug };
+        this.ownership.captureDefinition(value, ref, pointer);
         this.coreNodes.set(value, ref);
         this.capturePolicyObject(value, ref);
     }
     captureFunction(value, ref, pointer) {
-        this.ownership.capture(value, `${ref.origin}:function.${ref.name}`, pointer);
+        this.ownership.captureDefinition(value, ref, pointer);
         this.capturePolicyObject(value, ref);
     }
     captureView(value, ref, pointer) {
-        this.ownership.capture(value, `${ref.origin}:view.${ref.name}`, pointer);
+        this.ownership.captureDefinition(value, ref, pointer);
         this.capturePolicyObject(value, ref);
     }
     resolveClass(input, kind, pointer) {
@@ -112,13 +112,18 @@ export class BuilderContext {
         const ref = isPolicyObjectRef(value)
             ? value
             : typeof value === 'object' && value !== null
-                ? this.policyObjects.get(value)
+                ? (this.policyObjects.get(value) ?? this.ownership.definition(value))
                 : undefined;
-        if (ref === undefined ||
-            ref.origin !== this.origin ||
-            !this.policyObjectRefs.has(definitionRefIndex(ref))) {
-            fail('BUILDER_POLICY_REF', pointer, 'Policy ref(...) must name one registered local Definition, Function, Policy, View, or Core Node.');
+        const dependency = ref === undefined ? undefined : this.#dependencies.get(ref.origin)?.schema;
+        const admitted = ref !== undefined &&
+            (ref.origin === this.origin
+                ? this.policyObjectRefs.has(definitionRefIndex(ref))
+                : dependency !== undefined && hasPolicyObject(dependency, ref));
+        if (!admitted || ref === undefined) {
+            fail('BUILDER_POLICY_REF', pointer, 'Policy ref(...) must name one registered local or direct-dependency Definition, Function, Policy, View, or Core Node.');
         }
+        if (ref.origin !== this.origin)
+            this.usedForeignOrigins.add(ref.origin);
         return { ...ref };
     }
     resolveCoreEndpoint(value, pointer) {
@@ -245,3 +250,17 @@ function definitionRefsOf(schema) {
     }
     return refs.sort(compareDefinitionRefs);
 }
+function hasPolicyObject(schema, ref) {
+    switch (ref.kind) {
+        case 'class':
+            return Object.hasOwn(schema.classes, ref.name);
+        case 'function':
+            return Object.hasOwn(schema.functions, ref.name);
+        case 'policy':
+            return Object.hasOwn(schema.policies, ref.name);
+        case 'view':
+            return Object.hasOwn(schema.views, ref.name);
+        case 'core':
+            return Object.hasOwn(schema.core.nodes, ref.name);
+    }
+}

package/dist/v1/builder/lowering/schema/ownership.d.ts

@@ -1,8 +1,8 @@
-import type { DefinitionRef } from '../../../addressing/index.js';
+import type { PolicyObjectRef } from '../../../language/policy/model/policy.js';
 export declare class OwnershipCapture {
     #private;
-    captureDefinition(value: object, ref: DefinitionRef, pointer: string): void;
+    captureDefinition(value: object, ref: PolicyObjectRef, pointer: string): void;
     capture(value: object, owner: string, pointer: string): void;
-    definition(value: object): DefinitionRef | undefined;
+    definition(value: object): PolicyObjectRef | undefined;
     commit(): void;
 }

package/dist/v1/compiled/admission/semantics.js

@@ -438,11 +438,8 @@ function validateCallablePolicy(context, entry, expression, inputIndex, fields,
                 !isSingleNodePathField(context, entry, inputIndex, object.field))
                 fail(`${path}/object`, 'Callable Policy input target must be a direct required single-Node Path field.');
         }
-        if (object.kind === 'ref') {
-            if (object.ref.origin !== entry.origin ||
-                context.definitions.get(Key.of(object.ref)) === undefined)
-                fail(`${path}/object/ref`, 'Callable Policy object refs must name an exact local Definition.');
-        }
+        // validateClosure already establishes that object refs name existing local
+        // or exact direct-dependency Definitions. Named Policy execution stays local.
         return;
     }
     const children = 'allOf' in expression ? expression.allOf : expression.anyOf;

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

@@ -122,7 +122,14 @@ function visitChecks(validation, typing, expression, context, pointer) {
 }
 function referenceContracts(validation, ref, pointer) {
     const candidate = validation.environment.candidate;
-    if (ref.origin !== candidate.origin)
+    const local = ref.origin === candidate.origin;
+    const direct = Object.values(candidate.dependencies).some((entry) => entry.origin === ref.origin);
+    const owner = local
+        ? candidate
+        : direct
+            ? validation.environment.dependencies.get(ref.origin)
+            : undefined;
+    if (owner === undefined)
         return invalidPolicyObjectRef(validation, ref, pointer);
     switch (ref.kind) {
         case 'class': {
@@ -132,26 +139,26 @@ function referenceContracts(validation, ref, pointer) {
                 : invalidPolicyObjectRef(validation, ref, pointer);
         }
         case 'function':
-            return candidate.functions[ref.name] === undefined
+            return owner.functions[ref.name] === undefined
                 ? invalidPolicyObjectRef(validation, ref, pointer)
                 : [{ kind: 'exact', ref: PROJECTION_FUNCTION }];
         case 'policy':
-            return candidate.policies[ref.name] === undefined
+            return owner.policies[ref.name] === undefined
                 ? invalidPolicyObjectRef(validation, ref, pointer)
                 : [{ kind: 'exact', ref: PROJECTION_POLICY }];
         case 'view':
-            return candidate.views[ref.name] === undefined
+            return owner.views[ref.name] === undefined
                 ? invalidPolicyObjectRef(validation, ref, pointer)
                 : [{ kind: 'exact', ref: PROJECTION_VIEW }];
         case 'core': {
-            const node = candidate.core.nodes[ref.name];
+            const node = owner.core.nodes[ref.name];
             if (node === undefined)
                 return invalidPolicyObjectRef(validation, ref, pointer);
             const resolved = validation.environment.resolve(node.class);
             const analyzed = validation.analysis.definitions.get(definitionRefIndex(node.class));
             // Core validation owns invalid Core Class diagnostics. Avoid adding Policy noise for
             // a Node that cannot materialize in the first place.
-            if (node.class.origin !== candidate.origin ||
+            if (node.class.origin !== owner.origin ||
                 resolved?.ref.kind !== 'class' ||
                 resolved.kind !== 'node' ||
                 analyzed === undefined) {
@@ -163,7 +170,7 @@ function referenceContracts(validation, ref, pointer) {
     return invalidPolicyObjectRef(validation, ref, pointer);
 }
 function invalidPolicyObjectRef(validation, ref, pointer) {
-    validation.add('PL_REF', `${pointer}/ref`, `${formatDefinitionRef(ref)} is not an exact local projected Policy object.`, formatDefinitionRef(ref));
+    validation.add('PL_REF', `${pointer}/ref`, `${formatDefinitionRef(ref)} is not an exact local or direct-dependency projected Policy object.`, formatDefinitionRef(ref));
     return undefined;
 }
 function selfContracts(validation, context, pointer) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-dsl",
-  "version": "0.2.0-beta.27",
+  "version": "0.2.0-beta.28",
   "description": "Astrale Kernel DSL - Schema authoring, inference, and IR serialization",
   "license": "Apache-2.0",
   "repository": {