@astrale-os/kernel-dsl 0.1.4 → 0.2.0-beta.1

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

@@ -1,11 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,21 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,18 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,26 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,43 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,18 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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"}

package/dist/schema/validators/ref-targets.js

@@ -1,53 +0,0 @@
-import { SchemaValidationError } from '../error.js';
-import { eachDef, isKnownDef } from '../refs.js';
-// Runtime symbol
-const REF_TAG_RUNTIME = Symbol.for('REF_TAG');
-/** Extract all ref targets from a Zod schema tree */
-function extractRefTargets(schema) {
-    if (schema === null || typeof schema !== 'object')
-        return [];
-    const targets = [];
-    const record = schema;
-    // Check for our REF_TAG brand
-    if (REF_TAG_RUNTIME in record) {
-        const meta = record[REF_TAG_RUNTIME];
-        if (meta.target && typeof meta.target === 'object') {
-            targets.push(meta.target);
-        }
-    }
-    // Walk into Zod internals to find nested refs
-    const zod = record;
-    const inner = zod.element ?? zod.innerType ?? zod._def?.innerType ?? zod._def?.type;
-    if (inner && typeof inner === 'object') {
-        targets.push(...extractRefTargets(inner));
-    }
-    return targets;
-}
-/** Validate that all ref() targets in params/returns point to known definitions */
-export function validateRefTargets(ctx) {
-    const validateFnRefs = (path, fnDef) => {
-        const params = fnDef.config.params;
-        if (params && typeof params === 'object' && typeof params !== 'function') {
-            for (const [paramName, paramSchema] of Object.entries(params)) {
-                for (const target of extractRefTargets(paramSchema)) {
-                    if (!isKnownDef(target, ctx.descriptorMap)) {
-                        throw new SchemaValidationError(`'${path}' param '${paramName}' references an unknown def`, `${path}.params.${paramName}`, 'a def in this schema or imported', 'unknown reference');
-                    }
-                }
-            }
-        }
-        for (const target of extractRefTargets(fnDef.config.returns)) {
-            if (!isKnownDef(target, ctx.descriptorMap)) {
-                throw new SchemaValidationError(`'${path}' return type references an unknown def`, `${path}.returns`, 'a def in this schema or imported', 'unknown reference');
-            }
-        }
-    };
-    for (const [name, def] of eachDef(ctx.interfaces, ctx.classes)) {
-        const methods = def.config.methods;
-        if (!methods)
-            continue;
-        for (const [methodName, methodDef] of Object.entries(methods)) {
-            validateFnRefs(`${name}.${methodName}`, methodDef);
-        }
-    }
-}

package/dist/serializer/context.d.ts

@@ -1,32 +0,0 @@
-import { z } from 'zod';
-import type { SchemaIR } from '../ir/index.js';
-import type { Schema } from '../schema/schema.js';
-export declare class SerializeContext {
-    private schema;
-    private descriptorMap;
-    private importedMaps;
-    private zodToTypeName;
-    private types;
-    private imports;
-    constructor(schema: Schema, options?: {
-        types?: Record<string, z.ZodType>;
-    });
-    run(): SchemaIR;
-    private serializeInterface;
-    private serializeNode;
-    private serializeEdge;
-    private resolveInherits;
-    private serializeEndpoint;
-    private serializeConstraints;
-    private serializeProperties;
-    private serializePropertySchema;
-    private serializeMethods;
-    private serializeFn;
-    private serializeParams;
-    private convertZodSchema;
-    private zodToJsonSchemaRaw;
-    private serializeData;
-    private buildNodeRef;
-    private getDefName;
-}
-//# sourceMappingURL=context.d.ts.map

package/dist/serializer/context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/serializer/context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAQvB,OAAO,KAAK,EACV,QAAQ,EAUT,MAAM,gBAAgB,CAAA;AACvB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAkBjD,qBAAa,gBAAgB;IAQzB,OAAO,CAAC,MAAM;IAPhB,OAAO,CAAC,aAAa,CAA4B;IACjD,OAAO,CAAC,YAAY,CAAiE;IACrF,OAAO,CAAC,aAAa,CAAmC;IACxD,OAAO,CAAC,KAAK,CAAiC;IAC9C,OAAO,CAAC,OAAO,CAAuC;IAEtD,YACU,MAAM,EAAE,MAAM,EACtB,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAA;KAAE,EAkBhD;IAED,GAAG,IAAI,QAAQ,CA6Bd;IAED,OAAO,CAAC,kBAAkB;IAe1B,OAAO,CAAC,aAAa;IAiBrB,OAAO,CAAC,aAAa;IAkBrB,OAAO,CAAC,eAAe;IAMvB,OAAO,CAAC,iBAAiB;IAYzB,OAAO,CAAC,oBAAoB;IAyB5B,OAAO,CAAC,mBAAmB;IAc3B,OAAO,CAAC,uBAAuB;IAQ/B,OAAO,CAAC,gBAAgB;IAYxB,OAAO,CAAC,WAAW;IAgBnB,OAAO,CAAC,eAAe;IAiCvB,OAAO,CAAC,gBAAgB;IAyBxB,OAAO,CAAC,kBAAkB;IAS1B,OAAO,CAAC,aAAa;IAOrB,OAAO,CAAC,YAAY;IAUpB,OAAO,CAAC,UAAU;CA0CnB"}

package/dist/serializer/context.js

@@ -1,308 +0,0 @@
-import { z } from 'zod';
-import { isEdge } from '../grammar/definition/discriminants.js';
-import { normalizeProperty } from '../grammar/facets/properties.js';
-import { buildDescriptorMap, findDefTransitive } from '../schema/refs.js';
-import { unwrapZod, getArrayElement, foldNullable, mapCardinality, hasRefTag, getRefMeta, getDataMeta, hasBitmaskTag, cleanJsonSchema, } from './helpers.js';
-export class SerializeContext {
-    schema;
-    descriptorMap;
-    importedMaps = [];
-    zodToTypeName = new WeakMap();
-    types = {};
-    imports = {};
-    constructor(schema, options) {
-        this.schema = schema;
-        this.descriptorMap = buildDescriptorMap(schema);
-        for (const imported of schema.imports ?? []) {
-            const importedMap = buildDescriptorMap(imported);
-            this.importedMaps.push({ origin: imported.domain, map: importedMap });
-            for (const [def, descriptor] of importedMap) {
-                this.descriptorMap.set(def, descriptor);
-            }
-        }
-        if (options?.types) {
-            for (const [name, zodSchema] of Object.entries(options.types)) {
-                this.zodToTypeName.set(zodSchema, name);
-                this.types[name] = this.zodToJsonSchemaRaw(zodSchema);
-            }
-        }
-    }
-    run() {
-        const interfaces = {};
-        const classes = {};
-        for (const [name, def] of Object.entries(this.schema.interfaces)) {
-            interfaces[name] = this.serializeInterface(name, def);
-        }
-        for (const [name, def] of Object.entries(this.schema.classes)) {
-            if (isEdge(def)) {
-                classes[name] = this.serializeEdge(name, def);
-            }
-            else {
-                classes[name] = this.serializeNode(name, def);
-            }
-        }
-        const result = {
-            version: '1.0',
-            domain: this.schema.domain,
-            types: this.types,
-            interfaces,
-            classes,
-        };
-        if (Object.keys(this.imports).length > 0) {
-            result.imports = this.imports;
-        }
-        return result;
-    }
-    serializeInterface(name, def) {
-        const { config } = def;
-        const result = {
-            type: 'interface',
-            name,
-            extends: this.resolveInherits(config),
-            properties: this.serializeProperties(config.properties),
-            methods: this.serializeMethods(config.methods, name),
-        };
-        const content = config.content;
-        const data = this.serializeData(content);
-        if (data)
-            result.data = data;
-        return result;
-    }
-    serializeNode(name, def) {
-        const { config } = def;
-        const result = {
-            type: 'node',
-            name,
-            implements: this.resolveInherits(config),
-            properties: this.serializeProperties(config.properties),
-            methods: this.serializeMethods(config.methods, name),
-        };
-        const content = config.content;
-        const data = this.serializeData(content);
-        if (data)
-            result.data = data;
-        const icon = config.icon;
-        if (typeof icon === 'string' && icon.length > 0)
-            result.icon = icon;
-        return result;
-    }
-    serializeEdge(name, def) {
-        const { config } = def;
-        const edgeDef = def;
-        const result = {
-            type: 'edge',
-            name,
-            implements: this.resolveInherits(config),
-            endpoints: [this.serializeEndpoint(edgeDef.from), this.serializeEndpoint(edgeDef.to)],
-            properties: this.serializeProperties(config.properties),
-            methods: this.serializeMethods(config.methods, name),
-        };
-        const constraints = this.serializeConstraints(config.constraints);
-        if (constraints)
-            result.constraints = constraints;
-        return result;
-    }
-    resolveInherits(config) {
-        const inherits = config.inherits;
-        if (!inherits)
-            return [];
-        return inherits.map((e) => this.getDefName(e));
-    }
-    serializeEndpoint(endpoint) {
-        const result = {
-            name: endpoint.as,
-            types: endpoint.types.map((t) => this.getDefName(t)),
-        };
-        if (endpoint.cardinality) {
-            const mapped = mapCardinality(endpoint.cardinality);
-            if (mapped)
-                result.cardinality = mapped;
-        }
-        return result;
-    }
-    serializeConstraints(constraints) {
-        if (!constraints)
-            return undefined;
-        const c = {};
-        let has = false;
-        if (constraints.unique) {
-            c.unique = true;
-            has = true;
-        }
-        if (constraints.noSelf) {
-            c.noSelf = true;
-            has = true;
-        }
-        if (constraints.acyclic) {
-            c.acyclic = true;
-            has = true;
-        }
-        if (constraints.symmetric) {
-            c.symmetric = true;
-            has = true;
-        }
-        return has ? c : undefined;
-    }
-    serializeProperties(attrs) {
-        if (!attrs)
-            return {};
-        const result = {};
-        for (const [name, input] of Object.entries(attrs)) {
-            const normalized = normalizeProperty(input);
-            const decl = this.serializePropertySchema(normalized.schema);
-            if (normalized.private)
-                decl.private = true;
-            result[name] = decl;
-        }
-        return result;
-    }
-    serializePropertySchema(schema) {
-        const { inner, nullable, defaultValue, hasDefault } = unwrapZod(schema);
-        let jsonSchema = this.convertZodSchema(inner);
-        if (nullable)
-            jsonSchema = foldNullable(jsonSchema);
-        if (hasDefault)
-            jsonSchema = { ...jsonSchema, default: defaultValue };
-        return jsonSchema;
-    }
-    serializeMethods(methods, _className) {
-        if (!methods)
-            return {};
-        const result = {};
-        for (const [name, def] of Object.entries(methods)) {
-            result[name] = this.serializeFn(name, def);
-        }
-        return result;
-    }
-    serializeFn(name, def) {
-        const { config } = def;
-        const { inner: returnInner, nullable: returnNullable } = unwrapZod(config.returns);
-        const fn = {
-            name,
-            params: this.serializeParams(config.params),
-            returns: this.convertZodSchema(returnInner),
-            static: config.static ?? false,
-            inheritance: config.inheritance ?? 'default',
-        };
-        if (returnNullable)
-            fn.returnsNullable = true;
-        if (config.output && config.output !== 'value')
-            fn.output = config.output;
-        return fn;
-    }
-    serializeParams(params) {
-        if (!params)
-            return {};
-        const resolved = typeof params === 'function' ? params() : params;
-        const result = {};
-        for (const [name, schema] of Object.entries(resolved)) {
-            const zodSchema = schema;
-            if (hasRefTag(zodSchema)) {
-                result[name] = this.buildNodeRef(zodSchema);
-                continue;
-            }
-            const { inner, nullable, defaultValue, hasDefault } = unwrapZod(zodSchema);
-            if (hasRefTag(inner)) {
-                let refSchema = this.buildNodeRef(inner);
-                if (nullable)
-                    refSchema = foldNullable(refSchema);
-                if (hasDefault)
-                    refSchema = { ...refSchema, default: defaultValue };
-                result[name] = refSchema;
-                continue;
-            }
-            let jsonSchema = this.convertZodSchema(inner);
-            if (nullable)
-                jsonSchema = foldNullable(jsonSchema);
-            if (hasDefault)
-                jsonSchema = { ...jsonSchema, default: defaultValue };
-            result[name] = jsonSchema;
-        }
-        return result;
-    }
-    convertZodSchema(schema) {
-        if (hasRefTag(schema))
-            return this.buildNodeRef(schema);
-        const dataMeta = getDataMeta(schema);
-        if (dataMeta) {
-            if (dataMeta.kind === 'self')
-                return { $dataRef: 'self' };
-            return { $dataRef: this.getDefName(dataMeta.target) };
-        }
-        if (hasBitmaskTag(schema))
-            return { type: 'integer', format: 'bitmask' };
-        const typeName = this.zodToTypeName.get(schema);
-        if (typeName)
-            return { $ref: `#/types/${typeName}` };
-        const element = getArrayElement(schema);
-        if (element) {
-            const itemSchema = this.convertZodSchema(element);
-            if (itemSchema.$nodeRef || itemSchema.$dataRef || itemSchema.$ref) {
-                return { type: 'array', items: itemSchema };
-            }
-        }
-        return this.zodToJsonSchemaRaw(schema);
-    }
-    zodToJsonSchemaRaw(schema) {
-        try {
-            const result = z.toJSONSchema(schema);
-            return cleanJsonSchema(result);
-        }
-        catch {
-            return {};
-        }
-    }
-    serializeData(data) {
-        if (!data || Object.keys(data).length === 0)
-            return undefined;
-        const objectSchema = z.object(data);
-        const result = z.toJSONSchema(objectSchema);
-        return cleanJsonSchema(result);
-    }
-    buildNodeRef(schema) {
-        const meta = getRefMeta(schema);
-        if (!meta)
-            return {};
-        const result = {
-            $nodeRef: this.getDefName(meta.target),
-        };
-        if (meta.includeData)
-            result.includeData = true;
-        return result;
-    }
-    getDefName(def) {
-        const descriptor = this.descriptorMap.get(def);
-        if (!descriptor) {
-            const transitive = findDefTransitive(this.schema, def);
-            if (transitive) {
-                throw new Error(`Serialization error: referenced def is declared in schema "${transitive.origin}" ` +
-                    `(reachable via ${transitive.path.join(' → ')}), but "${transitive.origin}" ` +
-                    `is not in the direct imports of "${this.schema.domain}". ` +
-                    `Add it to your schema's \`imports\` array.`);
-            }
-            throw new Error(`Serialization error: referenced def not found in schema "${this.schema.domain}" ` +
-                `or any of its imports. Is the def from an unregistered schema?`);
-        }
-        // Already recorded — early-out doubles as cycle-guard for the recursion below.
-        if (this.imports[descriptor.name])
-            return descriptor.name;
-        for (const { origin, map } of this.importedMaps) {
-            const importedDescriptor = map.get(def);
-            if (!importedDescriptor)
-                continue;
-            this.imports[descriptor.name] = { origin, definition: importedDescriptor.group };
-            // Recurse on `inherits` so transitive ancestors are recorded too:
-            // a method materialized via an indirect ancestor (e.g.
-            // `View → UI → Function → Identity` where only Function is referenced
-            // directly) must qualify to the ancestor's owning schema, not ours.
-            // The early-out above keeps the recursion cycle-safe.
-            const inherits = def.config.inherits;
-            if (inherits) {
-                for (const parent of inherits)
-                    this.getDefName(parent);
-            }
-            return descriptor.name;
-        }
-        return descriptor.name;
-    }
-}

package/dist/serializer/helpers.d.ts

@@ -1,34 +0,0 @@
-import type { z } from 'zod';
-import type { Cardinality } from '../grammar/facets/endpoints.js';
-export declare function getZodDef(schema: z.ZodType): Record<string, any> | null;
-export declare function getZodTypeName(def: Record<string, any>): string | undefined;
-export declare function getZodInner(def: Record<string, any>): z.ZodType | null;
-export interface UnwrapResult {
-    inner: z.ZodType;
-    nullable: boolean;
-    defaultValue: unknown;
-    hasDefault: boolean;
-}
-export declare function unwrapZod(schema: z.ZodType): UnwrapResult;
-export declare function getArrayElement(schema: z.ZodType): z.ZodType | null;
-export declare function hasRefTag(schema: z.ZodType): boolean;
-export declare function getRefMeta(schema: z.ZodType): {
-    target: object;
-    includeData: boolean;
-} | null;
-export declare function hasDataTag(schema: z.ZodType): boolean;
-export declare function getDataMeta(schema: z.ZodType): {
-    kind: 'self';
-} | {
-    kind: 'grant';
-    target: object;
-} | null;
-export declare function hasBitmaskTag(schema: z.ZodType): boolean;
-export type JsonSchema = Record<string, unknown>;
-export declare function foldNullable(schema: JsonSchema): JsonSchema;
-export declare function mapCardinality(c: Cardinality): {
-    min: number;
-    max: number | null;
-} | undefined;
-export declare function cleanJsonSchema(schema: Record<string, unknown>): JsonSchema;
-//# sourceMappingURL=helpers.d.ts.map

package/dist/serializer/helpers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/serializer/helpers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAE5B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAA;AAYjE,wBAAgB,SAAS,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI,CAEvE;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,GAAG,SAAS,CAE3E;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC,OAAO,GAAG,IAAI,CAEtE;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,CAAC,CAAC,OAAO,CAAA;IAChB,QAAQ,EAAE,OAAO,CAAA;IACjB,YAAY,EAAE,OAAO,CAAA;IACrB,UAAU,EAAE,OAAO,CAAA;CACpB;AAED,wBAAgB,SAAS,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,GAAG,YAAY,CA0CzD;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,OAAO,GAAG,IAAI,CAQnE;AAID,wBAAgB,SAAS,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,GAAG,OAAO,CAEpD;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CAG7F;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,GAAG,OAAO,CAErD;AAED,wBAAgB,WAAW,CACzB,MAAM,EAAE,CAAC,CAAC,OAAO,GAChB;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAG7D;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,GAAG,OAAO,CAExD;AAID,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAEhD,wBAAgB,YAAY,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU,CAS3D;AAED,wBAAgB,cAAc,CAAC,CAAC,EAAE,WAAW,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GAAG,SAAS,CAW9F;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,UAAU,CAO3E"}