@astrale-os/kernel-core 0.4.1

package/dist/domain/compile/validation/validate.js

@@ -0,0 +1,159 @@
+/**
+ * Build-time validation for domain schemas.
+ *
+ * Called from compileDomain() to surface:
+ * - Interface name collisions (warning) — same-named interfaces from different domains
+ * - Reserved structural field names (error) — id, slug, class, attrs, $d, etc.
+ * - Flat-spread shadowing (warning) — class vs interface names, property vs method names,
+ *   schema names that shadow CompiledDomain fields, property names that shadow entry fields.
+ */
+import { parseDefRef } from '@astrale-os/kernel-dsl';
+import { RESERVED_NODE_FIELDS } from '#domain/compile/catalog/system-properties';
+import { CompilationError } from '#domain/compile/errors';
+import { methodsOf } from '#domain/compile/method/types';
+/**
+ * Reserved names on a compiled domain — shadowed if a class/interface has
+ * the same name. Only the `$` sigil is reserved; everything else on K is
+ * a schema member (flat access).
+ */
+const DOMAIN_RESERVED_FIELDS = ['$'];
+/**
+ * Reserved names on every MemberRefEntry — shadowed if a property/method
+ * has the same name.
+ */
+const MEMBER_ENTRY_FIELDS = ['ref', 'key', 'path', '$'];
+/**
+ * Validate a compiled domain's property index and method map.
+ *
+ * Throws CompilationError for hard errors (reserved names).
+ * Returns a list of warnings for soft issues (interface/method name collisions).
+ */
+export function validateDomain(origin, propertyIndex, schema, methods) {
+    const warnings = [];
+    collectFlatShadowWarnings(schema, methods, warnings);
+    // Check 1: Reserved structural field names for types
+    const definitionNames = [...Object.keys(schema.interfaces), ...Object.keys(schema.classes)];
+    for (const name of definitionNames) {
+        if (RESERVED_NODE_FIELDS.includes(name)) {
+            throw new CompilationError('RESERVED_NAME', `Type name "${name}" is reserved as a structural node field (${RESERVED_NODE_FIELDS.join(', ')}). Rename it.`, { domain: origin, name });
+        }
+    }
+    // Check 2: Reserved structural field names for methods. `methods` is keyed
+    // by defRef (`class.X` / `interface.X`); show the bare name in the message.
+    for (const [defRefKey, defMethods] of Object.entries(methods)) {
+        const defName = parseDefRef(defRefKey).name;
+        for (const methodName of Object.keys(defMethods)) {
+            if (RESERVED_NODE_FIELDS.includes(methodName)) {
+                throw new CompilationError('RESERVED_NAME', `Method name "${methodName}" on definition "${defName}" is reserved as a structural node field (${RESERVED_NODE_FIELDS.join(', ')}). Rename it.`, { domain: origin, definition: defName, methodName });
+            }
+        }
+    }
+    // Check 3: Interface name collisions — per-class, check if multiple
+    // owner-domains contribute the same owner name. Shape:
+    // byClass[className][domain][owner][prop] = mapping.
+    for (const [className, byDomain] of Object.entries(propertyIndex.byClass)) {
+        const ownerDomains = new Map();
+        for (const [domain, byOwner] of Object.entries(byDomain)) {
+            for (const ownerName of Object.keys(byOwner)) {
+                if (!ownerDomains.has(ownerName))
+                    ownerDomains.set(ownerName, new Set());
+                ownerDomains.get(ownerName).add(domain);
+            }
+        }
+        for (const [ownerName, domains] of ownerDomains) {
+            if (domains.size > 1) {
+                warnings.push({
+                    code: 'AMBIGUOUS_INTERFACE',
+                    message: `Class "${className}" inherits multiple interfaces named "${ownerName}" from domains: ${[...domains].sort().join(', ')}. Sugar access node.${ownerName}.* will throw at runtime — use node.$d('<domain>').${ownerName}.* instead.`,
+                    context: { className, interfaceName: ownerName, domains: [...domains] },
+                });
+            }
+        }
+        // Check 4: Method name vs interface name collision — a top-level method
+        // would shadow the interface namespace sugar.
+        const classMethods = methodsOf(methods, 'class', className);
+        if (classMethods) {
+            const interfaceNames = new Set(ownerDomains.keys());
+            for (const methodName of Object.keys(classMethods)) {
+                if (interfaceNames.has(methodName)) {
+                    warnings.push({
+                        code: 'METHOD_INTERFACE_COLLISION',
+                        message: `Class "${className}" has method "${methodName}" which collides with interface name "${methodName}". Top-level node.${methodName} will resolve to the interface, not the method — use node.$d('<domain>').${classMethods[methodName].origin}.${methodName}() instead.`,
+                        context: { className, methodName },
+                    });
+                }
+            }
+        }
+    }
+    return warnings;
+}
+/**
+ * Warn on flat-sugar shadowing — at the top-level CompiledDomain and on each
+ * MemberRefEntry. Shadowed names remain reachable via $c/$i/$p/$m.
+ */
+function collectFlatShadowWarnings(schema, methods, warnings) {
+    const interfaceNames = new Set(Object.keys(schema.interfaces));
+    const classNames = new Set(Object.keys(schema.classes));
+    // Top-level: class or interface name shadows the `$` sigil.
+    for (const name of [...interfaceNames, ...classNames]) {
+        if (DOMAIN_RESERVED_FIELDS.includes(name)) {
+            warnings.push({
+                code: 'DOMAIN_FIELD_SHADOW',
+                message: `Type "${name}" shadows K.${name} (engine sigil). Use K.$.c('${name}') or K.$.i('${name}') instead.`,
+                context: { name },
+            });
+        }
+    }
+    // Top-level: class name same as interface name — one shadows the other.
+    for (const name of classNames) {
+        if (interfaceNames.has(name)) {
+            warnings.push({
+                code: 'CLASS_INTERFACE_NAME_COLLISION',
+                message: `Class "${name}" shares its name with an interface. Flat K.${name} is ambiguous — use K.$.c('${name}') or K.$.i('${name}').`,
+                context: { name },
+            });
+        }
+    }
+    // Per-member: property/method names shadowing entry fields or each other.
+    // Iterate per group so the method lookup is kind-correct even when a class
+    // and an interface share a name (the methods map is keyed by defRef).
+    const memberGroups = [
+        ['interface', schema.interfaces],
+        ['class', schema.classes],
+    ];
+    for (const [kind, defs] of memberGroups) {
+        for (const [defName, def] of Object.entries(defs)) {
+            const ownProps = def.config.properties;
+            const ownMethods = methodsOf(methods, kind, defName);
+            const methodNames = new Set(ownMethods ? Object.keys(ownMethods) : []);
+            if (ownProps) {
+                for (const propName of Object.keys(ownProps)) {
+                    if (MEMBER_ENTRY_FIELDS.includes(propName)) {
+                        warnings.push({
+                            code: 'ENTRY_FIELD_SHADOW',
+                            message: `Property "${propName}" on "${defName}" shadows the ref entry field ".${propName}" via flat access. Use K.${defName}.$.p('${propName}') instead.`,
+                            context: { defName, propName },
+                        });
+                    }
+                    if (methodNames.has(propName)) {
+                        warnings.push({
+                            code: 'PROPERTY_METHOD_NAME_COLLISION',
+                            message: `Property "${propName}" on "${defName}" shares its name with a method. Flat K.${defName}.${propName} is ambiguous — use K.${defName}.$.p('${propName}') or K.${defName}.$.m('${propName}').`,
+                            context: { defName, propName },
+                        });
+                    }
+                }
+            }
+            for (const methodName of methodNames) {
+                if (MEMBER_ENTRY_FIELDS.includes(methodName)) {
+                    warnings.push({
+                        code: 'ENTRY_FIELD_SHADOW',
+                        message: `Method "${methodName}" on "${defName}" shadows the ref entry field ".${methodName}" via flat access. Use K.${defName}.$.m('${methodName}') instead.`,
+                        context: { defName, methodName },
+                    });
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=validate.js.map

package/dist/domain/compile/validation/validate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.js","sourceRoot":"","sources":["../../../../domain/compile/validation/validate.ts"],"names":[],"mappings":"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"}

package/dist/domain/deserialize/deserialize.d.ts

@@ -0,0 +1,55 @@
+/**
+ * deserializeDomainFromGraph — inverse of `materialize()`.
+ *
+ * The Domain node carries the full SchemaIR as a JSON blob (`schema`
+ * property, written at serialize time). That blob is the single source of
+ * truth for types, inheritance, imports, and the IR passthrough — no walk
+ * over Class/Interface nodes is needed for any of it.
+ *
+ * The graph is still read for:
+ *   - Class/Interface self node PATHS (layout may differ from defaultLayout
+ *     under a custom mount, so we pick up the real absolute paths).
+ *   - Per-type `propertyIndex` blobs — denormalized PropertyMapping snapshot
+ *     that lets us reconstruct DomainPropertyIndex without loading foreign
+ *     domains.
+ *   - Function nodes + `method_of` edges — the source of truth for
+ *     cross-domain method inheritance (local methods can also be read here
+ *     rather than duplicating resolution logic from IR).
+ *   - Core (instance) nodes — not part of IR, only present in the graph.
+ *
+ * Known, documented losses:
+ *   - `schema` (builder Schema) — Zod-opaque. Placeholder.
+ *   - `methods[*].fnDef` — source-form Zod validators don't round-trip.
+ *     Placeholder preserves `.config.{params,returns}` access.
+ */
+import type { CompiledDomain } from '#domain/compile/types';
+import type { EdgeSpec, NodeSpec } from '#graph';
+import type { Graph } from '#graph/graph';
+/**
+ * Deserialize a `Graph` into a `CompiledDomain`.
+ *
+ * Input is a `Graph` — well-formed (absolute paths,
+ * hydrated `Path` instances, deduped ids) by construction. Callers receiving
+ * wire-form `{ nodes, edges }` must run it through `Graph.from` first; the
+ * type signature makes that conversion explicit rather than implicit.
+ */
+export declare function deserializeDomainFromGraph(graph: Graph): CompiledDomain;
+/**
+ * Does a Domain node carry a serialized SchemaIR blob?
+ *
+ * True for every domain materialized via `serialize` — the blob is the single
+ * source of truth `deserializeDomainFromGraph` reads. False only for the
+ * bootstrap kernel Domain node, created by raw boot Cypher that never writes
+ * the blob (consumers seed the kernel from the in-bundle compiled domain
+ * instead). Callers iterating Domain nodes use this to skip the ones that
+ * aren't graph-deserializable, rather than catching `MISSING_SCHEMA_IR`.
+ */
+export declare function carriesSchemaIR(node: {
+    props?: Record<string, unknown>;
+}): boolean;
+/**
+ * Consumers used to import these separately — re-export so the single-file
+ * deserializer doesn't force callers to track the internal module layout.
+ */
+export type { NodeSpec, EdgeSpec };
+//# sourceMappingURL=deserialize.d.ts.map

package/dist/domain/deserialize/deserialize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deserialize.d.ts","sourceRoot":"","sources":["../../../domain/deserialize/deserialize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AA+BH,OAAO,KAAK,EAAE,cAAc,EAAgB,MAAM,uBAAuB,CAAA;AAEzE,OAAO,KAAK,EAAE,QAAQ,EAAQ,QAAQ,EAAE,MAAM,QAAQ,CAAA;AACtD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AAoCzC;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,KAAK,GAAG,cAAc,CA8DvE;AAsBD;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,GAAG,OAAO,CAGlF;AAk2BD;;;GAGG;AACH,YAAY,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAA"}