@astrale-os/kernel-dsl 0.1.0

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

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

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

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

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

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

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

package/dist/serializer/helpers.js

@@ -0,0 +1,115 @@
+// Runtime symbols
+const REF_TAG_RUNTIME = Symbol.for('REF_TAG');
+const DATA_TAG_RUNTIME = Symbol.for('DATA_TAG');
+const BITMASK_TAG_RUNTIME = Symbol.for('BITMASK_TAG');
+// ── Zod introspection ─────────────────────────────────────────────────
+export function getZodDef(schema) {
+    return schema?._zod?.def ?? schema?._def ?? null;
+}
+export function getZodTypeName(def) {
+    return def.typeName ?? def.type;
+}
+export function getZodInner(def) {
+    return def.innerType ?? def.inner ?? null;
+}
+export function unwrapZod(schema) {
+    let current = schema;
+    let nullable = false;
+    let defaultValue = undefined;
+    let hasDefault = false;
+    for (let i = 0; i < 10; i++) {
+        const def = getZodDef(current);
+        if (!def)
+            break;
+        const typeName = getZodTypeName(def);
+        if (typeName === 'ZodOptional' || typeName === 'optional') {
+            nullable = true;
+            const inner = getZodInner(def);
+            if (!inner)
+                break;
+            current = inner;
+            continue;
+        }
+        if (typeName === 'ZodNullable' || typeName === 'nullable') {
+            nullable = true;
+            const inner = getZodInner(def);
+            if (!inner)
+                break;
+            current = inner;
+            continue;
+        }
+        if (typeName === 'ZodDefault' || typeName === 'default') {
+            hasDefault = true;
+            const dv = def.defaultValue !== undefined ? def.defaultValue : def.value;
+            defaultValue = typeof dv === 'function' ? dv() : dv;
+            const inner = getZodInner(def);
+            if (!inner)
+                break;
+            current = inner;
+            continue;
+        }
+        break;
+    }
+    return { inner: current, nullable, defaultValue, hasDefault };
+}
+export function getArrayElement(schema) {
+    const def = getZodDef(schema);
+    if (!def)
+        return null;
+    const typeName = getZodTypeName(def);
+    if (typeName === 'ZodArray' || typeName === 'array') {
+        return def.element ?? def.items ?? null;
+    }
+    return null;
+}
+// ── Brand detection (new symbol-based) ────────────────────────────────
+export function hasRefTag(schema) {
+    return schema !== null && typeof schema === 'object' && REF_TAG_RUNTIME in schema;
+}
+export function getRefMeta(schema) {
+    if (!hasRefTag(schema))
+        return null;
+    return schema[REF_TAG_RUNTIME];
+}
+export function hasDataTag(schema) {
+    return schema !== null && typeof schema === 'object' && DATA_TAG_RUNTIME in schema;
+}
+export function getDataMeta(schema) {
+    if (!hasDataTag(schema))
+        return null;
+    return schema[DATA_TAG_RUNTIME];
+}
+export function hasBitmaskTag(schema) {
+    return schema !== null && typeof schema === 'object' && BITMASK_TAG_RUNTIME in schema;
+}
+export function foldNullable(schema) {
+    if (schema.type) {
+        const existing = Array.isArray(schema.type) ? schema.type : [schema.type];
+        if (!existing.includes('null')) {
+            return { ...schema, type: [...existing, 'null'] };
+        }
+        return schema;
+    }
+    return { anyOf: [schema, { type: 'null' }] };
+}
+export function mapCardinality(c) {
+    switch (c) {
+        case '0..1':
+            return { min: 0, max: 1 };
+        case '1':
+            return { min: 1, max: 1 };
+        case '0..*':
+            return undefined;
+        case '1..*':
+            return { min: 1, max: null };
+    }
+}
+export function cleanJsonSchema(schema) {
+    const result = {};
+    for (const [key, value] of Object.entries(schema)) {
+        if (key === '$schema')
+            continue;
+        result[key] = value;
+    }
+    return result;
+}

package/dist/serializer/index.d.ts

@@ -0,0 +1,2 @@
+export { serialize, type SerializeOptions } from './serialize.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/serializer/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,gBAAgB,EAAE,MAAM,gBAAgB,CAAA"}

package/dist/serializer/index.js

@@ -0,0 +1 @@
+export { serialize } from './serialize.js';

package/dist/serializer/serialize.d.ts

@@ -0,0 +1,12 @@
+import type { z } from 'zod';
+import type { SchemaIR } from '../ir/index.js';
+import type { Schema } from '../schema/schema.js';
+export interface SerializeOptions {
+    /**
+     * Named types to hoist into the IR `types` record.
+     * Pass Zod schemas that should be shared across multiple properties/params.
+     */
+    types?: Record<string, z.ZodType>;
+}
+export declare function serialize(schema: Schema, options?: SerializeOptions): SchemaIR;
+//# sourceMappingURL=serialize.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../../src/serializer/serialize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAE5B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAC9C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAIjD,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAA;CAClC;AAED,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,QAAQ,CAG9E"}

package/dist/serializer/serialize.js

@@ -0,0 +1,5 @@
+import { SerializeContext } from './context.js';
+export function serialize(schema, options) {
+    const ctx = new SerializeContext(schema, options);
+    return ctx.run();
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@astrale-os/kernel-dsl",
+  "version": "0.1.0",
+  "description": "Astrale Kernel DSL - Schema authoring, inference, and IR serialization",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./ir": {
+      "types": "./dist/ir/index.d.ts",
+      "import": "./dist/ir/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "restricted",
+    "registry": "https://npm.pkg.github.com"
+  },
+  "dependencies": {
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@astrale/typescript-config": "npm:@jsr/astrale__typescript-config@~1.1.0",
+    "@typescript/native-preview": "latest",
+    "typescript": "~6.0.1-rc",
+    "vitest": "^4.0.18"
+  },
+  "peerDependencies": {
+    "typescript": "~6.0.1-rc"
+  },
+  "scripts": {
+    "build": "tsgo",
+    "clean": "rm -rf dist",
+    "typecheck": "tsgo --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "preinstall": "node .check-workspace.cjs"
+  }
+}