@astrale-os/kernel-core 0.9.0-beta.8 → 1.0.0-beta.1

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

@@ -0,0 +1,36 @@
+import { normalizeProperties } from '#graph/properties';
+import { K } from '../index.js';
+/** The Properties of a declaration or relation that carries none. */
+export const EMPTY_PROPERTIES = normalizeProperties({});
+/** The of_domain Properties locating a declaration under its Domain member name. */
+export function memberProperties(member) {
+    return normalizeProperties({ [K.classes.of_domain.self.properties.member.key]: member });
+}
+/** The Descriptable Property of an authored description, if any. */
+export function descriptionProperties(description) {
+    if (description === undefined)
+        return {};
+    return { [K.classes.Descriptable.self.properties.description.key]: description };
+}
+/** The Function Node Properties carrying a Function's or Method's complete callable contract. */
+export function callableProperties(declaration) {
+    const method = 'static' in declaration;
+    return normalizeProperties({
+        ...descriptionProperties(declaration.description),
+        [K.classes.Function.self.properties.kind.key]: method ? 'method' : 'function',
+        [K.classes.Function.self.properties.input.key]: declaration.input,
+        [K.classes.Function.self.properties.output.key]: declaration.output,
+        [K.classes.Function.self.properties.auth.key]: declaration.auth,
+        ...(declaration.policy === undefined
+            ? {}
+            : {
+                [K.classes.Function.self.properties.policy.key]: declaration.policy,
+            }),
+        ...(method
+            ? {
+                [K.classes.Function.self.properties.static.key]: declaration.static,
+                [K.classes.Function.self.properties.abstract.key]: declaration.abstract,
+            }
+            : {}),
+    });
+}

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

@@ -0,0 +1,7 @@
+import { type SourceDomain, type schema } from '@astrale-os/kernel-dsl/v1';
+import { type Part, type Payload } from './part.js';
+/**
+ * Relate each local Definition to its parent Classes and governing Policies, and the entrypoint
+ * View to its Domain.
+ */
+export declare function projectRelations<Extra extends object>(domain: SourceDomain<schema.DomainSchema>, managed: Part<Extra>, payload: Payload<Extra>): void;

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

@@ -0,0 +1,61 @@
+import { Key, } from '@astrale-os/kernel-dsl/v1';
+import { isClassRuleChecks } from '@astrale-os/kernel-dsl/v1/language';
+import { Path } from '#graph/path';
+import { normalizeProperties } from '#graph/properties';
+import { K } from '../index.js';
+import { is, projectedDefinitions } from './definitions.js';
+import { edge } from './part.js';
+import { EMPTY_PROPERTIES } from './properties.js';
+const OPERATIONS = ['read', 'traverse'];
+/**
+ * Relate each local Definition to its parent Classes and governing Policies, and the entrypoint
+ * View to its Domain.
+ */
+export function projectRelations(domain, managed, payload) {
+    for (const [definition] of projectedDefinitions(domain)) {
+        const source = managed.endpoint(Path.project(definition.ref).raw);
+        const relate = (target, classRef, extra) => managed.edges.push(edge(source, managed.endpoint(target), classRef, extra));
+        if (is(definition, 'class')) {
+            for (const parent of definition.definition.extends) {
+                relate(Path.project(parent).raw, K.classes.extends.ref, payload(() => EMPTY_PROPERTIES));
+            }
+            for (const [policy, operations] of governingPolicies(definition)) {
+                relate(Path.project(policy).raw, K.classes.governed_by.ref, payload(() => normalizeProperties({
+                    [K.classes.governed_by.self.properties.operations.key]: operations,
+                })));
+            }
+        }
+        // The one entrypoint View links to its own Domain; other Views relate to it only by of_domain.
+        if (is(definition, 'view') && domain.source.entrypoint?.name === definition.ref.name) {
+            relate(Path.domain(domain.origin).raw, K.classes.entrypoint.ref, payload(() => EMPTY_PROPERTIES));
+        }
+    }
+}
+/** Each distinct Policy of a Class, with the operations it governs in canonical order. */
+function governingPolicies(definition) {
+    const policies = definition.definition.policies;
+    const grouped = new Map();
+    for (const operation of OPERATIONS) {
+        const declared = policies[operation];
+        // The rule `false` names no Policy, so it projects no relation; a rule governs through every
+        // Policy it checks.
+        if (typeof declared !== 'object')
+            continue;
+        for (const policy of isClassRuleChecks(declared) ? checkedPolicies(declared) : [declared]) {
+            const key = Key.of(policy);
+            const existing = grouped.get(key);
+            if (existing === undefined)
+                grouped.set(key, { policy, operations: [operation] });
+            else if (!existing.operations.includes(operation))
+                existing.operations.push(operation);
+        }
+    }
+    return [...grouped.values()].map(({ policy, operations }) => [policy, Object.freeze(operations)]);
+}
+function checkedPolicies(rule) {
+    if ('check' in rule)
+        return [rule.check];
+    if ('sameNode' in rule)
+        return [];
+    return ('allOf' in rule ? rule.allOf : rule.anyOf).flatMap(checkedPolicies);
+}

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

@@ -1,10 +1,11 @@
 import type { Key, Revision } from '@astrale-os/kernel-dsl/v1';
-import type { GraphSpec, GraphSpecEdge, LocalBinding } from '#graph/graph';
+import type { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
+import type { GraphSpec, GraphSpecEdge, GraphSpecEndpoint, LocalAlias } from '#graph/graph';
 import type { NodePath } from '#graph/path';
 export interface ProjectionPart {
     readonly graph: GraphSpec;
     /** Canonical locator of every anonymous Node declared by the projection. */
-    readonly paths: ReadonlyMap<LocalBinding, NodePath>;
+    readonly paths: ReadonlyMap<LocalAlias, NodePath>;
 }
 export interface CoreProjection extends ProjectionPart {
     /** Runtime-owned locator relations that associate authored Core Nodes with their Domain. */
@@ -16,4 +17,28 @@ export interface Projection {
     readonly managed: ProjectionPart;
     readonly core: CoreProjection;
 }
-//# sourceMappingURL=types.d.ts.map
+/** Declaration identity only; this is not a Graph Node with absent or defaulted Properties. */
+export interface ProjectionTopologyNode {
+    readonly as: LocalAlias;
+    readonly class: ClassKey;
+}
+export interface ProjectionTopologyEdge {
+    readonly source: GraphSpecEndpoint;
+    readonly target: GraphSpecEndpoint;
+    readonly class: ClassKey;
+}
+export interface ProjectionTopologyPart {
+    readonly paths: ReadonlyMap<LocalAlias, NodePath>;
+    readonly nodes: readonly ProjectionTopologyNode[];
+    readonly edges: readonly ProjectionTopologyEdge[];
+}
+export interface CoreProjectionTopology extends ProjectionTopologyPart {
+    readonly locators: readonly ProjectionTopologyEdge[];
+}
+/** Symbolic ownership coordinates without materialized schema Property payloads. */
+export interface ProjectionTopology {
+    readonly origin: Key.Origin;
+    readonly revision: Revision;
+    readonly managed: ProjectionTopologyPart;
+    readonly core: CoreProjectionTopology;
+}

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

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=types.js.map