@astrale-os/kernel-dsl 0.1.0

package/dist/schema/refs.js

@@ -0,0 +1,116 @@
+/** Separator used in ref strings (package-level constant) */
+export const REF_SEPARATOR = '.';
+/** Build a DefRef string */
+export function defRef(kind, name) {
+    return `${kind}${REF_SEPARATOR}${name}`;
+}
+/**
+ * Parse a DefRef (`class.Name` / `interface.Name`) back into its kind + bare
+ * name. Member names never contain the separator, so a single split on the
+ * first `.` is exact. Inverse of {@link defRef}.
+ */
+export function parseDefRef(ref) {
+    const i = ref.indexOf(REF_SEPARATOR);
+    if (i < 0) {
+        throw new Error(`malformed DefRef "${ref}": expected "<kind>${REF_SEPARATOR}<name>"`);
+    }
+    return { kind: ref.slice(0, i), name: ref.slice(i + 1) };
+}
+/** Build a MethodRef string */
+export function methodRef(kind, name, method) {
+    return `${kind}${REF_SEPARATOR}${name}${REF_SEPARATOR}${method}`;
+}
+/**
+ * Build a reverse map from def objects to their descriptor.
+ * Used for schema-scoped lookups.
+ */
+export function buildDescriptorMap(schema) {
+    const map = new Map();
+    for (const [name, def] of Object.entries(schema.interfaces)) {
+        map.set(def, { group: 'interface', name, ref: defRef('interface', name) });
+    }
+    for (const [name, def] of Object.entries(schema.classes)) {
+        map.set(def, { group: 'class', name, ref: defRef('class', name) });
+    }
+    return map;
+}
+/**
+ * Build a combined descriptor map that includes both the schema's own defs and all imports.
+ * Call once, then pass to isKnownDef for O(1) lookups.
+ */
+export function buildDefDescriptorMap(schema) {
+    const map = buildDescriptorMap(schema);
+    for (const imported of schema.imports ?? []) {
+        const importedMap = buildDescriptorMap(imported);
+        for (const [def, identity] of importedMap) {
+            map.set(def, identity);
+        }
+    }
+    return map;
+}
+/** Check if a def exists in the descriptor map */
+export function isKnownDef(def, descriptorMap) {
+    return descriptorMap.has(def);
+}
+/**
+ * Walk `schema.imports` transitively (BFS, cycle-safe) and find the declaring
+ * schema of `target`. Returns the schema's origin plus the chain of origins
+ * traversed to reach it (e.g. `['a.com', 'b.com']` if `target` lives in `b.com`
+ * which was imported by `a.com` which was imported by the root). Returns
+ * `null` if `target` is not reachable through any import chain.
+ *
+ * Used by error diagnostics to distinguish "def from transitively-imported
+ * schema" from "def from no known schema".
+ */
+export function findDefTransitive(root, target) {
+    const visited = new Set([root]);
+    const queue = (root.imports ?? []).map((s) => ({
+        schema: s,
+        path: [s.domain],
+    }));
+    while (queue.length > 0) {
+        const { schema, path } = queue.shift();
+        if (visited.has(schema))
+            continue;
+        visited.add(schema);
+        if (buildDescriptorMap(schema).has(target)) {
+            return { origin: schema.domain, path };
+        }
+        for (const next of schema.imports ?? []) {
+            if (visited.has(next))
+                continue;
+            queue.push({ schema: next, path: [...path, next.domain] });
+        }
+    }
+    return null;
+}
+/** Build a flat map of all qualified method refs: `{group}.{name}.{method}` → FnDef */
+export function buildMethodRefs(schema) {
+    const fns = {};
+    const processGroup = (defs, kind) => {
+        for (const [name, def] of Object.entries(defs)) {
+            const methods = def.config.methods;
+            if (!methods)
+                continue;
+            for (const [methodName, fnDef] of Object.entries(methods)) {
+                fns[methodRef(kind, name, methodName)] = fnDef;
+            }
+        }
+    };
+    processGroup(schema.interfaces, 'interface');
+    processGroup(schema.classes, 'class');
+    return fns;
+}
+/**
+ * Iterate every def across both groups (interfaces first, then classes)
+ * WITHOUT collapsing same-named defs.
+ *
+ * Unlike `{ ...interfaces, ...classes }`, this preserves a class and an
+ * interface that share a name (e.g. the `Function` interface + the `Function`
+ * node class): both are yielded, so neither is silently dropped from a
+ * resolution or validation pass. For schemas with names unique across groups
+ * the behaviour is identical to the old spread.
+ */
+export function eachDef(interfaces, classes) {
+    return [...Object.entries(interfaces), ...Object.entries(classes)];
+}

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

@@ -0,0 +1,5 @@
+export { resolveConfigThunks, resolveParamThunks } from './thunks.js';
+export { resolveSelfReferences } from './self.js';
+export { resolveAllMethods } from './methods.js';
+export { resolveAllProperties, resolveAllPropertyKeys } from './properties.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/schema/resolve/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/schema/resolve/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AACrE,OAAO,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAA;AACjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAChD,OAAO,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAA"}

package/dist/schema/resolve/index.js

@@ -0,0 +1,4 @@
+export { resolveConfigThunks, resolveParamThunks } from './thunks.js';
+export { resolveSelfReferences } from './self.js';
+export { resolveAllMethods } from './methods.js';
+export { resolveAllProperties, resolveAllPropertyKeys } from './properties.js';

package/dist/schema/resolve/methods.d.ts

@@ -0,0 +1,8 @@
+import type { AnyDef } from '../../grammar/definition/discriminants.js';
+import type { FnDef } from '../../grammar/function/def.js';
+/**
+ * Walk the inheritance chain and collect all methods for a definition.
+ * Own methods shadow inherited ones.
+ */
+export declare function resolveAllMethods(def: AnyDef): Record<string, FnDef>;
+//# sourceMappingURL=methods.d.ts.map

package/dist/schema/resolve/methods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"methods.d.ts","sourceRoot":"","sources":["../../../src/schema/resolve/methods.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAA;AACvE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,+BAA+B,CAAA;AAE1D;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAepE"}

package/dist/schema/resolve/methods.js

@@ -0,0 +1,17 @@
+/**
+ * Walk the inheritance chain and collect all methods for a definition.
+ * Own methods shadow inherited ones.
+ */
+export function resolveAllMethods(def) {
+    const result = {};
+    // Collect from ancestors first (later inherits entries shadow earlier ones)
+    const inherits = def.config.inherits ?? [];
+    for (const parent of inherits) {
+        const parentMethods = resolveAllMethods(parent);
+        Object.assign(result, parentMethods);
+    }
+    // Own methods shadow inherited
+    const ownMethods = def.config.methods ?? {};
+    Object.assign(result, ownMethods);
+    return result;
+}

package/dist/schema/resolve/properties.d.ts

@@ -0,0 +1,13 @@
+import type { AnyDef } from '../../grammar/definition/discriminants.js';
+import type { NormalizedProperty } from '../../grammar/facets/properties.js';
+/**
+ * Walk the inheritance chain and collect all property keys.
+ * Returns a Set of all available property names (own + inherited).
+ */
+export declare function resolveAllPropertyKeys(def: AnyDef): Set<string>;
+/**
+ * Walk the inheritance chain and collect all properties resolved.
+ * Own properties shadow inherited ones.
+ */
+export declare function resolveAllProperties(def: AnyDef): Record<string, NormalizedProperty>;
+//# sourceMappingURL=properties.d.ts.map

package/dist/schema/resolve/properties.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"properties.d.ts","sourceRoot":"","sources":["../../../src/schema/resolve/properties.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAA;AACvE,OAAO,KAAK,EAAiB,kBAAkB,EAAE,MAAM,oCAAoC,CAAA;AAI3F;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAgB/D;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAepF"}

package/dist/schema/resolve/properties.js

@@ -0,0 +1,36 @@
+import { normalizeProperty } from '../../grammar/facets/properties.js';
+/**
+ * Walk the inheritance chain and collect all property keys.
+ * Returns a Set of all available property names (own + inherited).
+ */
+export function resolveAllPropertyKeys(def) {
+    const keys = new Set();
+    const inherits = def.config.inherits ?? [];
+    for (const parent of inherits) {
+        for (const key of resolveAllPropertyKeys(parent)) {
+            keys.add(key);
+        }
+    }
+    const ownProps = def.config.properties ?? {};
+    for (const key of Object.keys(ownProps)) {
+        keys.add(key);
+    }
+    return keys;
+}
+/**
+ * Walk the inheritance chain and collect all properties resolved.
+ * Own properties shadow inherited ones.
+ */
+export function resolveAllProperties(def) {
+    const result = {};
+    const inherits = def.config.inherits ?? [];
+    for (const parent of inherits) {
+        const parentProps = resolveAllProperties(parent);
+        Object.assign(result, parentProps);
+    }
+    const ownProps = def.config.properties ?? {};
+    for (const [key, prop] of Object.entries(ownProps)) {
+        result[key] = normalizeProperty(prop);
+    }
+    return result;
+}

package/dist/schema/resolve/self.d.ts

@@ -0,0 +1,7 @@
+import type { AnyDef } from '../../grammar/definition/discriminants.js';
+/**
+ * Replace all `ref(SELF)` targets in a def's config tree with the actual def object.
+ * Walks the config recursively looking for RefSchema objects whose target is SELF.
+ */
+export declare function resolveSelfReferences(def: AnyDef): void;
+//# sourceMappingURL=self.d.ts.map

package/dist/schema/resolve/self.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"self.d.ts","sourceRoot":"","sources":["../../../src/schema/resolve/self.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAA;AAavE;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAEvD"}

package/dist/schema/resolve/self.js

@@ -0,0 +1,32 @@
+// Runtime symbols matching declared unique symbols
+const SELF_TAG_RUNTIME = Symbol.for('SELF_TAG');
+const REF_TAG_RUNTIME = Symbol.for('REF_TAG');
+/** Check if a value is a SELF token */
+function isSelf(value) {
+    return typeof value === 'object' && value !== null && SELF_TAG_RUNTIME in value;
+}
+/**
+ * Replace all `ref(SELF)` targets in a def's config tree with the actual def object.
+ * Walks the config recursively looking for RefSchema objects whose target is SELF.
+ */
+export function resolveSelfReferences(def) {
+    walkAndReplace(def.config, def, new WeakSet());
+}
+function walkAndReplace(obj, actualDef, visited) {
+    if (!obj || typeof obj !== 'object' || visited.has(obj))
+        return;
+    visited.add(obj);
+    const record = obj;
+    // Check if this object is a RefSchema with a SELF target
+    if (REF_TAG_RUNTIME in record) {
+        const refMeta = record[REF_TAG_RUNTIME];
+        if (isSelf(refMeta.target)) {
+            ;
+            refMeta.target = actualDef;
+        }
+    }
+    // Recurse into all values
+    for (const value of Object.values(record)) {
+        walkAndReplace(value, actualDef, visited);
+    }
+}

package/dist/schema/resolve/thunks.d.ts

@@ -0,0 +1,12 @@
+import type { AnyDef } from '../../grammar/definition/discriminants.js';
+/**
+ * Resolve config thunks: if a def's config was wrapped in `() => ({...})`,
+ * call the thunk and replace the config with its result.
+ */
+export declare function resolveConfigThunks(name: string, def: AnyDef): void;
+/**
+ * Resolve param thunks: if a method's params was wrapped in `() => ({...})`,
+ * call the thunk and replace params with its result.
+ */
+export declare function resolveParamThunks(name: string, def: AnyDef): void;
+//# sourceMappingURL=thunks.d.ts.map

package/dist/schema/resolve/thunks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thunks.d.ts","sourceRoot":"","sources":["../../../src/schema/resolve/thunks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAA;AAKvE;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAanE;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAkBlE"}

package/dist/schema/resolve/thunks.js

@@ -0,0 +1,36 @@
+import { SchemaValidationError } from '../error.js';
+/**
+ * Resolve config thunks: if a def's config was wrapped in `() => ({...})`,
+ * call the thunk and replace the config with its result.
+ */
+export function resolveConfigThunks(name, def) {
+    if (typeof def.config === 'function') {
+        try {
+            ;
+            def.config = def.config();
+        }
+        catch (e) {
+            throw new SchemaValidationError(`Failed to resolve config thunk for '${name}': ${String(e)}`, name, 'resolvable config thunk', 'unresolvable');
+        }
+    }
+}
+/**
+ * Resolve param thunks: if a method's params was wrapped in `() => ({...})`,
+ * call the thunk and replace params with its result.
+ */
+export function resolveParamThunks(name, def) {
+    const methods = def.config.methods;
+    if (!methods)
+        return;
+    for (const [methodName, fnDef] of Object.entries(methods)) {
+        if (typeof fnDef.config.params === 'function') {
+            try {
+                ;
+                fnDef.config.params = fnDef.config.params();
+            }
+            catch (e) {
+                throw new SchemaValidationError(`Failed to resolve param thunk for '${name}.${methodName}': ${String(e)}`, `${name}.${methodName}.params`, 'resolvable thunk', 'unresolvable');
+            }
+        }
+    }
+}

package/dist/schema/schema.d.ts

@@ -0,0 +1,21 @@
+import type { AnyInterfaceDef, AnyClassDef } from '../grammar/definition/discriminants.js';
+import type { FnDef } from '../grammar/function/def.js';
+/**
+ * The rich schema object — two groups (interfaces + classes),
+ * pre-resolved types, ref maps, domain. Produced by `defineSchema`.
+ *
+ * @typeParam I — Record of interface definitions (node-interface | edge-interface)
+ * @typeParam C — Record of class definitions (node-class | edge-class)
+ *
+ * `imports` is runtime-only at the type level — widened to `readonly Schema[]`
+ * so that the concrete types of imported schemas don't flow into consumers'
+ * declared types (declaration-emit size regression — see docs/specs/schema-type-inference-size.md).
+ */
+export interface Schema<I extends Record<string, AnyInterfaceDef> = Record<string, AnyInterfaceDef>, C extends Record<string, AnyClassDef> = Record<string, AnyClassDef>> {
+    readonly domain: string;
+    readonly interfaces: Readonly<I>;
+    readonly classes: Readonly<C>;
+    readonly functions: Record<string, FnDef>;
+    readonly imports: readonly Schema[];
+}
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/schema/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,wCAAwC,CAAA;AAC1F,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAA;AAEvD;;;;;;;;;;GAUG;AACH,MAAM,WAAW,MAAM,CACrB,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,EAC3E,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC;IAEnE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAA;IAChC,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAA;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;IACzC,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAA;CACpC"}

package/dist/schema/schema.js

@@ -0,0 +1 @@
+export {};

package/dist/schema/validators/context.d.ts

@@ -0,0 +1,13 @@
+import type { AnyDef, AnyInterfaceDef, AnyClassDef } from '../../grammar/definition/discriminants.js';
+import type { DefDescriptor } from '../refs.js';
+import type { Schema } from '../schema.js';
+/** Validation context passed to each validator */
+export interface SchemaContext {
+    readonly domain: string;
+    readonly interfaces: Record<string, AnyInterfaceDef>;
+    readonly classes: Record<string, AnyClassDef>;
+    readonly imports: readonly Schema[];
+    /** Descriptor map for all defs in this schema */
+    readonly descriptorMap: Map<AnyDef, DefDescriptor>;
+}
+//# sourceMappingURL=context.d.ts.map

package/dist/schema/validators/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/schema/validators/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EACN,eAAe,EACf,WAAW,EACZ,MAAM,2CAA2C,CAAA;AAClD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAC/C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAE1C,kDAAkD;AAClD,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;IACpD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;IAC7C,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAA;IACnC,iDAAiD;IACjD,QAAQ,CAAC,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;CACnD"}

package/dist/schema/validators/context.js

@@ -0,0 +1 @@
+export {};

package/dist/schema/validators/endpoints.d.ts

@@ -0,0 +1,4 @@
+import type { SchemaContext } from './context.js';
+/** Validate endpoint types exist and cardinality values are valid */
+export declare function validateEndpoints(ctx: SchemaContext): void;
+//# sourceMappingURL=endpoints.d.ts.map

package/dist/schema/validators/endpoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"endpoints.d.ts","sourceRoot":"","sources":["../../../src/schema/validators/endpoints.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAQjD,qEAAqE;AACrE,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,aAAa,GAAG,IAAI,CAkC1D"}

package/dist/schema/validators/endpoints.js

@@ -0,0 +1,26 @@
+import { isEdge } from '../../grammar/definition/discriminants.js';
+import { SchemaValidationError } from '../error.js';
+import { eachDef, isKnownDef } from '../refs.js';
+const VALID_CARDINALITIES = ['0..1', '1', '0..*', '1..*'];
+/** Validate endpoint types exist and cardinality values are valid */
+export function validateEndpoints(ctx) {
+    for (const [name, def] of eachDef(ctx.interfaces, ctx.classes)) {
+        if (!isEdge(def))
+            continue;
+        const from = def.from;
+        const to = def.to;
+        for (const endpoint of [from, to]) {
+            // Rule 6: Endpoint types exist
+            for (const type of endpoint.types) {
+                if (!isKnownDef(type, ctx.descriptorMap)) {
+                    throw new SchemaValidationError(`Definition '${name}' references an unknown type in endpoint '${endpoint.as}'`, `${name}.${endpoint.as}`, 'a def in this schema or imported', 'unknown reference');
+                }
+            }
+            // Rule 10: Cardinality valid
+            if (endpoint.cardinality !== undefined &&
+                !VALID_CARDINALITIES.includes(endpoint.cardinality)) {
+                throw new SchemaValidationError(`Invalid cardinality '${String(endpoint.cardinality)}' on '${name}' endpoint '${endpoint.as}'`, `${name}.${endpoint.as}.cardinality`, VALID_CARDINALITIES.join(', '), String(endpoint.cardinality));
+            }
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+import type { SchemaContext } from './context.js';
+export type { SchemaContext } from './context.js';
+export { validateUniqueNames } from './names.js';
+export { validateInheritance } from './inheritance.js';
+export { validateEndpoints } from './endpoints.js';
+export { validateIndexes } from './indexes.js';
+export { validateRefTargets } from './ref-targets.js';
+export { validateMethods } from './methods.js';
+/** Run all schema validators in sequence */
+export declare function validateSchema(ctx: SchemaContext): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/schema/validators/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/schema/validators/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AASjD,YAAY,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AACjD,OAAO,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAA;AAChD,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAE9C,4CAA4C;AAC5C,wBAAgB,cAAc,CAAC,GAAG,EAAE,aAAa,GAAG,IAAI,CAOvD"}

package/dist/schema/validators/index.js

@@ -0,0 +1,21 @@
+import { validateEndpoints } from './endpoints.js';
+import { validateIndexes } from './indexes.js';
+import { validateInheritance } from './inheritance.js';
+import { validateMethods } from './methods.js';
+import { validateUniqueNames } from './names.js';
+import { validateRefTargets } from './ref-targets.js';
+export { validateUniqueNames } from './names.js';
+export { validateInheritance } from './inheritance.js';
+export { validateEndpoints } from './endpoints.js';
+export { validateIndexes } from './indexes.js';
+export { validateRefTargets } from './ref-targets.js';
+export { validateMethods } from './methods.js';
+/** Run all schema validators in sequence */
+export function validateSchema(ctx) {
+    validateUniqueNames(ctx);
+    validateInheritance(ctx);
+    validateEndpoints(ctx);
+    validateIndexes(ctx);
+    validateRefTargets(ctx);
+    validateMethods(ctx);
+}

package/dist/schema/validators/indexes.d.ts

@@ -0,0 +1,4 @@
+import type { SchemaContext } from './context.js';
+/** Validate that all indexed properties exist on the definition or its ancestors */
+export declare function validateIndexes(ctx: SchemaContext): void;
+//# sourceMappingURL=indexes.d.ts.map

package/dist/schema/validators/indexes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexes.d.ts","sourceRoot":"","sources":["../../../src/schema/validators/indexes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAMjD,oFAAoF;AACpF,wBAAgB,eAAe,CAAC,GAAG,EAAE,aAAa,GAAG,IAAI,CAmBxD"}

package/dist/schema/validators/indexes.js

@@ -0,0 +1,18 @@
+import { SchemaValidationError } from '../error.js';
+import { eachDef } from '../refs.js';
+import { resolveAllPropertyKeys } from '../resolve/properties.js';
+/** Validate that all indexed properties exist on the definition or its ancestors */
+export function validateIndexes(ctx) {
+    for (const [name, def] of eachDef(ctx.interfaces, ctx.classes)) {
+        const indexes = def.config.indexes;
+        if (!indexes)
+            continue;
+        const available = resolveAllPropertyKeys(def);
+        for (const idx of indexes) {
+            const prop = typeof idx === 'string' ? idx : idx.property;
+            if (!available.has(prop)) {
+                throw new SchemaValidationError(`Index on '${name}' references unknown property '${prop}'`, `${name}.indexes`, [...available].join(', ') || '(no properties)', prop);
+            }
+        }
+    }
+}

package/dist/schema/validators/inheritance.d.ts

@@ -0,0 +1,4 @@
+import type { SchemaContext } from './context.js';
+/** Validate inheritance rules for all definitions */
+export declare function validateInheritance(ctx: SchemaContext): void;
+//# sourceMappingURL=inheritance.d.ts.map

package/dist/schema/validators/inheritance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inheritance.d.ts","sourceRoot":"","sources":["../../../src/schema/validators/inheritance.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAMjD,qDAAqD;AACrD,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,aAAa,GAAG,IAAI,CAsC5D"}

package/dist/schema/validators/inheritance.js

@@ -0,0 +1,26 @@
+import { isAbstract, isNode } from '../../grammar/definition/discriminants.js';
+import { SchemaValidationError } from '../error.js';
+import { eachDef, isKnownDef } from '../refs.js';
+/** Validate inheritance rules for all definitions */
+export function validateInheritance(ctx) {
+    for (const [name, def] of eachDef(ctx.interfaces, ctx.classes)) {
+        const parents = def.config.inherits;
+        if (!parents)
+            continue;
+        for (const parent of parents) {
+            // Rule 3: Inheritance targets exist
+            if (!isKnownDef(parent, ctx.descriptorMap)) {
+                throw new SchemaValidationError(`Definition '${name}' inherits from an unknown type`, `${name}.inherits`, 'a def in this schema or imported', 'unknown reference');
+            }
+            // Rule 5: No concrete inheritance — only abstract can be inherited
+            if (!isAbstract(parent)) {
+                throw new SchemaValidationError(`Definition '${name}' inherits from a concrete type (kind: '${parent.__kind}'). Only interfaces can be inherited.`, `${name}.inherits`, 'node-interface | edge-interface', parent.__kind);
+            }
+            // Rule 4: Kind match — node defs inherit node interfaces only;
+            // edge defs can inherit from both edge interfaces and node interfaces (mixins)
+            if (isNode(def) && !isNode(parent)) {
+                throw new SchemaValidationError(`Node definition '${name}' inherits from an edge interface`, `${name}.inherits`, 'node-interface', parent.__kind);
+            }
+        }
+    }
+}

package/dist/schema/validators/methods.d.ts

@@ -0,0 +1,9 @@
+import type { SchemaContext } from './context.js';
+/**
+ * Validate method inheritance rules:
+ * - Sealed methods are not overridden
+ * - Concrete defs implement all inherited abstract methods
+ * - Inheritance modifier only allowed on interfaces
+ */
+export declare function validateMethods(ctx: SchemaContext): void;
+//# sourceMappingURL=methods.d.ts.map

package/dist/schema/validators/methods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"methods.d.ts","sourceRoot":"","sources":["../../../src/schema/validators/methods.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAOjD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,aAAa,GAAG,IAAI,CAkDxD"}

package/dist/schema/validators/methods.js

@@ -0,0 +1,43 @@
+import { isConcrete } from '../../grammar/definition/discriminants.js';
+import { SchemaValidationError } from '../error.js';
+import { eachDef } from '../refs.js';
+import { resolveAllMethods } from '../resolve/methods.js';
+/**
+ * Validate method inheritance rules:
+ * - Sealed methods are not overridden
+ * - Concrete defs implement all inherited abstract methods
+ * - Inheritance modifier only allowed on interfaces
+ */
+export function validateMethods(ctx) {
+    for (const [name, def] of eachDef(ctx.interfaces, ctx.classes)) {
+        const ownMethods = def.config.methods ?? {};
+        // Concrete defs must not declare inheritance on own methods
+        if (isConcrete(def)) {
+            for (const [methodName, fnDef] of Object.entries(ownMethods)) {
+                if (fnDef.config.inheritance) {
+                    throw new SchemaValidationError(`Concrete def '${name}' declares '${methodName}' with inheritance '${fnDef.config.inheritance}'. ` +
+                        `The 'inheritance' modifier is only allowed on interface methods.`, `${name}.${methodName}.inheritance`, 'undefined (no inheritance on concrete defs)', fnDef.config.inheritance);
+                }
+            }
+        }
+        // Check sealed override violations
+        const parents = def.config.inherits ?? [];
+        for (const parent of parents) {
+            const parentMethods = resolveAllMethods(parent);
+            for (const [methodName, parentFn] of Object.entries(parentMethods)) {
+                if (parentFn.config.inheritance === 'sealed' && methodName in ownMethods) {
+                    throw new SchemaValidationError(`Definition '${name}' overrides sealed method '${methodName}'`, `${name}.${methodName}`, 'no override (method is sealed)', 'override declared');
+                }
+            }
+        }
+        // Concrete defs must implement all inherited abstract methods
+        if (isConcrete(def)) {
+            const allInherited = resolveAllMethods(def);
+            for (const [methodName, fnDef] of Object.entries(allInherited)) {
+                if (fnDef.config.inheritance === 'abstract' && !(methodName in ownMethods)) {
+                    throw new SchemaValidationError(`Concrete def '${name}' does not implement abstract method '${methodName}'`, `${name}.${methodName}`, 'method implementation', 'missing');
+                }
+            }
+        }
+    }
+}

package/dist/schema/validators/names.d.ts

@@ -0,0 +1,4 @@
+import type { SchemaContext } from './context.js';
+/** Validate that no two definitions share a name within the same group */
+export declare function validateUniqueNames(ctx: SchemaContext): void;
+//# sourceMappingURL=names.d.ts.map

package/dist/schema/validators/names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"names.d.ts","sourceRoot":"","sources":["../../../src/schema/validators/names.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAIjD,0EAA0E;AAC1E,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,aAAa,GAAG,IAAI,CA0B5D"}

package/dist/schema/validators/names.js

@@ -0,0 +1,18 @@
+import { SchemaValidationError } from '../error.js';
+/** Validate that no two definitions share a name within the same group */
+export function validateUniqueNames(ctx) {
+    const interfaceNames = new Set();
+    for (const name of Object.keys(ctx.interfaces)) {
+        if (interfaceNames.has(name)) {
+            throw new SchemaValidationError(`Duplicate interface name '${name}'`, 'interfaces', 'unique names', name);
+        }
+        interfaceNames.add(name);
+    }
+    const classNames = new Set();
+    for (const name of Object.keys(ctx.classes)) {
+        if (classNames.has(name)) {
+            throw new SchemaValidationError(`Duplicate class name '${name}'`, 'classes', 'unique names', name);
+        }
+        classNames.add(name);
+    }
+}

package/dist/schema/validators/ref-targets.d.ts

@@ -0,0 +1,4 @@
+import type { SchemaContext } from './context.js';
+/** Validate that all ref() targets in params/returns point to known definitions */
+export declare function validateRefTargets(ctx: SchemaContext): void;
+//# sourceMappingURL=ref-targets.d.ts.map

package/dist/schema/validators/ref-targets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ref-targets.d.ts","sourceRoot":"","sources":["../../../src/schema/validators/ref-targets.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAiCjD,mFAAmF;AACnF,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,aAAa,GAAG,IAAI,CAoC3D"}