@astrale-os/kernel-dsl 0.1.5 → 0.2.0-beta.10

package/dist/value/decode.js

@@ -0,0 +1,108 @@
+import { printParseErrorCode, visit } from 'jsonc-parser';
+import { DecodeError } from './error.js';
+import { limitsFor } from './limits.js';
+import { assertDecodedString, assertSourceString } from './unicode.js';
+const decoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+/** Strictly decode one bounded JSON value. */
+export function decode(input, options) {
+    const limits = limitsFor(options);
+    const source = sourceFor(input, limits);
+    if (source.charCodeAt(0) === 0xfeff) {
+        throw new DecodeError('JSON_SYNTAX', 'A byte-order mark is not JSON whitespace', 0);
+    }
+    scan(source, limits);
+    try {
+        return JSON.parse(source);
+    }
+    catch (error) {
+        throw new DecodeError('JSON_SYNTAX', 'Native JSON decoding rejected the strictly scanned input', 0, { cause: error });
+    }
+}
+function sourceFor(input, limits) {
+    if (typeof input === 'string') {
+        assertSourceString(input, limits.maxBytes);
+        return input;
+    }
+    if (input.byteLength > limits.maxBytes) {
+        throw new DecodeError('JSON_LIMIT', `JSON input exceeds the ${limits.maxBytes}-byte limit`, 0);
+    }
+    try {
+        return decoder.decode(input);
+    }
+    catch (error) {
+        throw new DecodeError('JSON_UTF8', 'Malformed UTF-8 JSON input', 0, { cause: error });
+    }
+}
+function scan(source, limits) {
+    const state = { frames: [], limits, members: 0 };
+    const beginContainer = (kind, offset) => {
+        countArrayItem(state, offset);
+        if (state.frames.length >= limits.maxDepth) {
+            throw new DecodeError('JSON_LIMIT', `JSON nesting exceeds the ${limits.maxDepth}-level limit`, offset);
+        }
+        state.frames.push(kind === 'object' ? { kind, names: new Set() } : { kind });
+    };
+    const visitor = {
+        onObjectBegin: (offset) => beginContainer('object', offset),
+        onObjectProperty: (name, offset) => {
+            const frame = state.frames.at(-1);
+            if (frame?.kind !== 'object')
+                failSyntax('Object member outside an Object', offset);
+            assertDecodedString(name, offset, limits.maxStringBytes);
+            if (frame.names.has(name)) {
+                throw new DecodeError('JSON_DUPLICATE_MEMBER', `Duplicate object member ${JSON.stringify(name)}`, offset);
+            }
+            frame.names.add(name);
+            addMembers(state, 1, offset);
+        },
+        onObjectEnd: (offset) => endContainer(state, 'object', offset),
+        onArrayBegin: (offset) => beginContainer('array', offset),
+        onArrayEnd: (offset) => endContainer(state, 'array', offset),
+        onLiteralValue: (value, offset) => {
+            countArrayItem(state, offset);
+            if (typeof value === 'string') {
+                assertDecodedString(value, offset, limits.maxStringBytes);
+            }
+            else if (typeof value === 'number') {
+                if (!Number.isFinite(value)) {
+                    throw new DecodeError('JSON_NUMBER', 'JSON number overflows finite IEEE-754 binary64', offset);
+                }
+                if (Object.is(value, -0)) {
+                    throw new DecodeError('JSON_NUMBER', 'JSON number resolves to negative zero', offset);
+                }
+            }
+        },
+        onError: (error, offset) => {
+            failSyntax(`Invalid JSON: ${printParseErrorCode(error)}`, offset);
+        },
+    };
+    try {
+        visit(source, visitor, {
+            allowEmptyContent: false,
+            allowTrailingComma: false,
+            disallowComments: true,
+        });
+    }
+    catch (error) {
+        if (error instanceof DecodeError)
+            throw error;
+        throw new DecodeError('JSON_SYNTAX', 'JSON scanner failed', 0, { cause: error });
+    }
+}
+function countArrayItem(state, offset) {
+    if (state.frames.at(-1)?.kind === 'array')
+        addMembers(state, 1, offset);
+}
+function addMembers(state, count, offset) {
+    state.members += count;
+    if (state.members > state.limits.maxMembers) {
+        throw new DecodeError('JSON_LIMIT', `JSON value exceeds the ${state.limits.maxMembers}-member limit`, offset);
+    }
+}
+function endContainer(state, kind, offset) {
+    if (state.frames.pop()?.kind !== kind)
+        failSyntax(`Mismatched ${kind} boundary`, offset);
+}
+function failSyntax(message, offset) {
+    throw new DecodeError('JSON_SYNTAX', message, offset);
+}

package/dist/value/equal.d.ts

@@ -0,0 +1,3 @@
+import type { Value } from './types.js';
+/** Compare two portable Values by their canonical JSON meaning. */
+export declare function equal(left: Value, right: Value): boolean;

package/dist/value/equal.js

@@ -0,0 +1,5 @@
+import { serialize } from './json.js';
+/** Compare two portable Values by their canonical JSON meaning. */
+export function equal(left, right) {
+    return left === right || serialize(left) === serialize(right);
+}

package/dist/value/error.d.ts

@@ -0,0 +1,12 @@
+export type BoundaryErrorCode = 'VALUE_TYPE' | 'VALUE_NUMBER' | 'VALUE_STRING' | 'VALUE_ARRAY' | 'VALUE_OBJECT' | 'VALUE_CYCLE' | 'VALUE_LIMIT' | 'VALUE_REFLECTION';
+export declare class BoundaryError extends TypeError {
+    readonly code: BoundaryErrorCode;
+    readonly pointer: string;
+    constructor(code: BoundaryErrorCode, message: string, pointer?: string, options?: ErrorOptions);
+}
+export type DecodeErrorCode = 'JSON_SYNTAX' | 'JSON_UTF8' | 'JSON_DUPLICATE_MEMBER' | 'JSON_NUMBER' | 'JSON_STRING' | 'JSON_LIMIT';
+export declare class DecodeError extends SyntaxError {
+    readonly code: DecodeErrorCode;
+    readonly offset: number;
+    constructor(code: DecodeErrorCode, message: string, offset: number, options?: ErrorOptions);
+}

package/dist/value/error.js

@@ -0,0 +1,21 @@
+export class BoundaryError extends TypeError {
+    code;
+    pointer;
+    constructor(code, message, pointer = '', options) {
+        const location = pointer === '' ? ' at the root' : ` at ${pointer}`;
+        super(`${message}${location}`, options);
+        this.name = 'BoundaryError';
+        this.code = code;
+        this.pointer = pointer;
+    }
+}
+export class DecodeError extends SyntaxError {
+    code;
+    offset;
+    constructor(code, message, offset, options) {
+        super(`${message} at UTF-16 offset ${offset}`, options);
+        this.name = 'DecodeError';
+        this.code = code;
+        this.offset = offset;
+    }
+}

package/dist/value/index.d.ts

@@ -0,0 +1,9 @@
+/** Portable values shared by the DSL and kernel contracts. */
+export { accept } from './accept.js';
+export { equal } from './equal.js';
+export { BoundaryError, DecodeError } from './error.js';
+export type { BoundaryErrorCode, DecodeErrorCode } from './error.js';
+export { defaultLimits } from './limits.js';
+export type { LimitOverrides, Limits, Options } from './limits.js';
+export * as json from './json.js';
+export type { Array, Object, Primitive, Value } from './types.js';

package/dist/value/index.js

@@ -0,0 +1,6 @@
+/** Portable values shared by the DSL and kernel contracts. */
+export { accept } from './accept.js';
+export { equal } from './equal.js';
+export { BoundaryError, DecodeError } from './error.js';
+export { defaultLimits } from './limits.js';
+export * as json from './json.js';

package/dist/value/json.d.ts

@@ -0,0 +1,3 @@
+export { encode, serialize } from './canonical.js';
+export { decode } from './decode.js';
+export { DecodeError } from './error.js';

package/dist/value/json.js

@@ -0,0 +1,3 @@
+export { encode, serialize } from './canonical.js';
+export { decode } from './decode.js';
+export { DecodeError } from './error.js';

package/dist/value/limits.d.ts

@@ -0,0 +1,21 @@
+export interface Limits {
+    /** Maximum UTF-8 size accepted from or emitted to a wire boundary. */
+    readonly maxBytes: number;
+    /** Maximum number of nested Array/Object containers, with a root container at depth one. */
+    readonly maxDepth: number;
+    /** Maximum total number of Object members plus Array elements. */
+    readonly maxMembers: number;
+    /** Maximum UTF-8 size of one string value or Object member name. */
+    readonly maxStringBytes: number;
+}
+export interface LimitOverrides {
+    readonly maxBytes?: number;
+    readonly maxDepth?: number;
+    readonly maxMembers?: number;
+    readonly maxStringBytes?: number;
+}
+export interface Options {
+    readonly limits?: LimitOverrides;
+}
+export declare const defaultLimits: Readonly<Limits>;
+export declare function limitsFor(options: Options | undefined): Limits;

package/dist/value/limits.js

@@ -0,0 +1,15 @@
+export const defaultLimits = Object.freeze({
+    maxBytes: 16 * 1024 * 1024,
+    maxDepth: 64,
+    maxMembers: 100_000,
+    maxStringBytes: 1024 * 1024,
+});
+export function limitsFor(options) {
+    const candidate = { ...defaultLimits, ...options?.limits };
+    for (const [name, value] of Object.entries(candidate)) {
+        if (!Number.isSafeInteger(value) || value < 1) {
+            throw new TypeError(`Portable value limit ${name} must be a positive safe integer.`);
+        }
+    }
+    return candidate;
+}

package/dist/value/types.d.ts

@@ -0,0 +1,6 @@
+export type Primitive = null | boolean | number | string;
+export type Array = readonly Value[];
+export type Object = {
+    readonly [name: string]: Value;
+};
+export type Value = Primitive | Array | Object;

package/dist/value/types.js

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

package/dist/value/unicode.d.ts

@@ -0,0 +1,4 @@
+export declare function utf8Length(value: string, max?: number): number;
+export declare function assertHostString(value: string, pointer: string, maxBytes: number): void;
+export declare function assertDecodedString(value: string, offset: number, maxBytes: number): void;
+export declare function assertSourceString(value: string, maxBytes: number): void;

package/dist/value/unicode.js

@@ -0,0 +1,64 @@
+import { BoundaryError, DecodeError } from './error.js';
+export function utf8Length(value, max = Number.MAX_SAFE_INTEGER) {
+    let bytes = 0;
+    for (let index = 0; index < value.length; index += 1) {
+        const codeUnit = value.charCodeAt(index);
+        if (codeUnit <= 0x7f)
+            bytes += 1;
+        else if (codeUnit <= 0x7ff)
+            bytes += 2;
+        else if (isHighSurrogate(codeUnit)) {
+            const next = value.charCodeAt(index + 1);
+            if (!isLowSurrogate(next))
+                return -index - 1;
+            bytes += 4;
+            index += 1;
+        }
+        else if (isLowSurrogate(codeUnit))
+            return -index - 1;
+        else
+            bytes += 3;
+        if (bytes > max)
+            return bytes;
+    }
+    return bytes;
+}
+export function assertHostString(value, pointer, maxBytes) {
+    if (value.includes('\u0000')) {
+        throw new BoundaryError('VALUE_STRING', 'Portable strings must not contain U+0000', pointer);
+    }
+    const length = utf8Length(value, maxBytes);
+    if (length < 0) {
+        throw new BoundaryError('VALUE_STRING', 'Expected a Unicode-scalar string', pointer);
+    }
+    if (length > maxBytes) {
+        throw new BoundaryError('VALUE_LIMIT', `String exceeds the ${maxBytes}-byte UTF-8 limit`, pointer);
+    }
+}
+export function assertDecodedString(value, offset, maxBytes) {
+    if (value.includes('\u0000')) {
+        throw new DecodeError('JSON_STRING', 'JSON string contains U+0000', offset);
+    }
+    const length = utf8Length(value, maxBytes);
+    if (length < 0) {
+        throw new DecodeError('JSON_STRING', 'JSON string contains a lone UTF-16 surrogate', offset);
+    }
+    if (length > maxBytes) {
+        throw new DecodeError('JSON_LIMIT', `JSON string exceeds the ${maxBytes}-byte UTF-8 limit`, offset);
+    }
+}
+export function assertSourceString(value, maxBytes) {
+    const length = utf8Length(value, maxBytes);
+    if (length < 0) {
+        throw new DecodeError('JSON_STRING', 'JSON text contains a lone UTF-16 surrogate', -length - 1);
+    }
+    if (length > maxBytes) {
+        throw new DecodeError('JSON_LIMIT', `JSON text exceeds the ${maxBytes}-byte limit`, 0);
+    }
+}
+function isHighSurrogate(codeUnit) {
+    return codeUnit >= 0xd800 && codeUnit <= 0xdbff;
+}
+function isLowSurrogate(codeUnit) {
+    return codeUnit >= 0xdc00 && codeUnit <= 0xdfff;
+}

package/dist/version/dispatch.d.ts

@@ -0,0 +1,24 @@
+import { type Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+export interface LanguageVersion {
+    readonly format: string;
+    readonly version: string;
+}
+export type LanguageVersionOf<Document extends LanguageVersion> = {
+    readonly format: Document['format'];
+    readonly version: Document['version'];
+};
+export interface VersionHandler<Result> extends LanguageVersion {
+    readonly accept: (input: JsonValue) => Result;
+}
+export type LanguageVersionErrorCode = 'LANGUAGE_VERSION_HEADER' | 'LANGUAGE_VERSION_UNSUPPORTED' | 'LANGUAGE_VERSION_HANDLER_DUPLICATE';
+export declare class LanguageVersionError extends Error {
+    readonly code: LanguageVersionErrorCode;
+    readonly language?: LanguageVersion;
+    constructor(code: LanguageVersionErrorCode, message: string, language?: LanguageVersion);
+}
+/** Read only the untrusted routing discriminator; this does not admit the document. */
+export declare function readLanguageVersion(input: unknown): LanguageVersion;
+type HandlerResult<Handlers extends readonly VersionHandler<unknown>[]> = Handlers[number] extends VersionHandler<infer Result> ? Result : never;
+/** Dispatch by exact format and version before invoking version-owned admission. */
+export declare function dispatchLanguageVersion<const Handlers extends readonly VersionHandler<unknown>[]>(input: unknown, handlers: Handlers): HandlerResult<Handlers>;
+export {};

package/dist/version/dispatch.js

@@ -0,0 +1,47 @@
+import { accept as acceptJsonValue, BoundaryError as JsonBoundaryError, } from '@astrale-os/kernel-dsl/value';
+export class LanguageVersionError extends Error {
+    code;
+    language;
+    constructor(code, message, language) {
+        super(message);
+        this.name = 'LanguageVersionError';
+        this.code = code;
+        this.language = language;
+    }
+}
+/** Read only the untrusted routing discriminator; this does not admit the document. */
+export function readLanguageVersion(input) {
+    let admitted;
+    try {
+        admitted = acceptJsonValue(input);
+    }
+    catch (error) {
+        if (error instanceof JsonBoundaryError) {
+            throw new LanguageVersionError('LANGUAGE_VERSION_HEADER', error.message);
+        }
+        throw error;
+    }
+    if (!isJsonObject(admitted) ||
+        typeof admitted.format !== 'string' ||
+        admitted.format.length === 0 ||
+        typeof admitted.version !== 'string' ||
+        admitted.version.length === 0) {
+        throw new LanguageVersionError('LANGUAGE_VERSION_HEADER', 'A versioned DSL document requires non-empty string format and version fields.');
+    }
+    return Object.freeze({ format: admitted.format, version: admitted.version });
+}
+function isJsonObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+/** Dispatch by exact format and version before invoking version-owned admission. */
+export function dispatchLanguageVersion(input, handlers) {
+    const language = readLanguageVersion(input);
+    const matches = handlers.filter((handler) => handler.format === language.format && handler.version === language.version);
+    if (matches.length === 0) {
+        throw new LanguageVersionError('LANGUAGE_VERSION_UNSUPPORTED', `Unsupported DSL document ${language.format}@${language.version}.`, language);
+    }
+    if (matches.length > 1) {
+        throw new LanguageVersionError('LANGUAGE_VERSION_HANDLER_DUPLICATE', `Multiple handlers claim DSL document ${language.format}@${language.version}.`, language);
+    }
+    return matches[0].accept(input);
+}

package/dist/version/index.d.ts

@@ -0,0 +1,2 @@
+export { LanguageVersionError, dispatchLanguageVersion, readLanguageVersion } from './dispatch.js';
+export type { LanguageVersion, LanguageVersionErrorCode, LanguageVersionOf, VersionHandler, } from './dispatch.js';

package/dist/version/index.js

@@ -0,0 +1 @@
+export { LanguageVersionError, dispatchLanguageVersion, readLanguageVersion } from './dispatch.js';

package/package.json

@@ -1,8 +1,13 @@
 {
   "name": "@astrale-os/kernel-dsl",
-  "version": "0.1.5",
+  "version": "0.2.0-beta.10",
   "description": "Astrale Kernel DSL - Schema authoring, inference, and IR serialization",
   "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/astrale-os/kernel.git",
+    "directory": "dsl"
+  },
   "files": [
     "dist"
   ],
@@ -14,9 +19,57 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
-    "./ir": {
-      "types": "./dist/ir/index.d.ts",
-      "import": "./dist/ir/index.js"
+    "./v1": {
+      "types": "./dist/v1/index.d.ts",
+      "import": "./dist/v1/index.js"
+    },
+    "./v1/addressing": {
+      "types": "./dist/v1/addressing/index.d.ts",
+      "import": "./dist/v1/addressing/index.js"
+    },
+    "./v1/builder": {
+      "types": "./dist/v1/builder/index.d.ts",
+      "import": "./dist/v1/builder/index.js"
+    },
+    "./v1/bundle": {
+      "types": "./dist/v1/bundle/index.d.ts",
+      "import": "./dist/v1/bundle/index.js"
+    },
+    "./v1/bundle/transport": {
+      "types": "./dist/v1/bundle/transport.d.ts",
+      "import": "./dist/v1/bundle/transport.js"
+    },
+    "./v1/compiled": {
+      "types": "./dist/v1/compiled/index.d.ts",
+      "import": "./dist/v1/compiled/index.js"
+    },
+    "./v1/compiled/loader": {
+      "types": "./dist/v1/compiled/loader/index.d.ts",
+      "import": "./dist/v1/compiled/loader/index.js"
+    },
+    "./v1/domain": {
+      "types": "./dist/v1/domain/index.d.ts",
+      "import": "./dist/v1/domain/index.js"
+    },
+    "./v1/language": {
+      "types": "./dist/v1/language/index.d.ts",
+      "import": "./dist/v1/language/index.js"
+    },
+    "./v1/schema": {
+      "types": "./dist/v1/schema/index.d.ts",
+      "import": "./dist/v1/schema/index.js"
+    },
+    "./v1/schema/revision": {
+      "types": "./dist/v1/schema/revision.d.ts",
+      "import": "./dist/v1/schema/revision.js"
+    },
+    "./v1/value/full-match": {
+      "types": "./dist/v1/value/full-match.d.ts",
+      "import": "./dist/v1/value/full-match.js"
+    },
+    "./value": {
+      "types": "./dist/value/index.d.ts",
+      "import": "./dist/value/index.js"
     },
     "./package.json": "./package.json"
   },
@@ -24,23 +77,30 @@
     "access": "public"
   },
   "dependencies": {
-    "zod": "^4.3.6"
+    "@noble/hashes": "2.3.0",
+    "jsonc-parser": "3.3.1",
+    "zod": "4.4.3"
   },
   "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"
+    "@typescript/native-preview": "7.0.0-dev.20260707.2",
+    "ajv": "^8.20.0",
+    "re2js": "2.8.6",
+    "typescript": "~6.0.3",
+    "vitest": "^4.1.10",
+    "yaml": "2.9.0"
   },
   "scripts": {
     "build": "tsgo",
     "clean": "rm -rf dist",
-    "typecheck": "tsgo --noEmit && tsgo --noEmit -p tsconfig.type-tests.json",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "preinstall": "node -e \"try{require('./.check-workspace.cjs')}catch{}\""
+    "conformance": "pnpm run spec:typecheck && tsgo --noEmit -p tsconfig.types.json && node scripts/check-public-api.mjs",
+    "generate:value-schema-validator": "node scripts/generate-value-schema-meta-validator.mjs",
+    "layout:check": "node scripts/check-layout.mjs",
+    "spec:typecheck": "tsgo --noEmit -p tsconfig.spec.json",
+    "typecheck": "tsgo --noEmit && tsgo --noEmit -p tsconfig.types.json",
+    "test": "pnpm run conformance && pnpm run layout:check && vitest run",
+    "test:file": "vitest run",
+    "test:semantic-lock": "pnpm run conformance && pnpm run layout:check && vitest run",
+    "test:watch": "vitest"
   }
 }

package/dist/builders/bitmask.d.ts

@@ -1,5 +0,0 @@
-import { z } from 'zod';
-import { type BitmaskDef } from '../grammar/values/bitmask.js';
-/** Create a bitmask value type — permissions bitfield (resolves to integer) */
-export declare function bitmask(): z.ZodNumber & BitmaskDef;
-//# sourceMappingURL=bitmask.d.ts.map

package/dist/builders/bitmask.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bitmask.d.ts","sourceRoot":"","sources":["../../src/builders/bitmask.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,8BAA8B,CAAA;AAK9D,+EAA+E;AAC/E,wBAAgB,OAAO,IAAI,CAAC,CAAC,SAAS,GAAG,UAAU,CAMlD"}

package/dist/builders/bitmask.js

@@ -1,12 +0,0 @@
-// oxlint-disable typescript/no-explicit-any
-import { z } from 'zod';
-import {} from '../grammar/values/bitmask.js';
-// Runtime symbol matching the declared unique symbol
-const BITMASK_TAG_RUNTIME = Symbol.for('BITMASK_TAG');
-/** Create a bitmask value type — permissions bitfield (resolves to integer) */
-export function bitmask() {
-    const schema = z.number().int().nonnegative();
-    schema[BITMASK_TAG_RUNTIME] = true;
-    return schema;
-}
-//# sourceMappingURL=bitmask.js.map

package/dist/builders/bitmask.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"bitmask.js","sourceRoot":"","sources":["../../src/builders/bitmask.ts"],"names":[],"mappings":"AAAA,4CAA4C;AAC5C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,OAAO,EAAmB,MAAM,8BAA8B,CAAA;AAE9D,qDAAqD;AACrD,MAAM,mBAAmB,GAAG,MAAM,CAAC,GAAG,CAAC,aAAa,CAAuB,CAAA;AAE3E,+EAA+E;AAC/E,MAAM,UAAU,OAAO;IACrB,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE,CAE5C;IAAC,MAAc,CAAC,mBAAmB,CAAC,GAAG,IAAI,CAAA;IAE5C,OAAO,MAAkC,CAAA;AAC3C,CAAC"}

package/dist/builders/data.d.ts

@@ -1,7 +0,0 @@
-import type { AnyDef } from '../grammar/definition/discriminants.js';
-import { type DataGrantSchema, type DataSelfSchema } from '../grammar/values/data.js';
-/** Create a data-self marker (owning node's datastore content) */
-export declare function data(): DataSelfSchema;
-/** Create a data-grant marker (another node's datastore content) */
-export declare function data<D extends AnyDef>(target: D): DataGrantSchema<D>;
-//# sourceMappingURL=data.d.ts.map

package/dist/builders/data.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"data.d.ts","sourceRoot":"","sources":["../../src/builders/data.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wCAAwC,CAAA;AAGpE,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,cAAc,EAAE,MAAM,2BAA2B,CAAA;AAKrF,kEAAkE;AAClE,wBAAgB,IAAI,IAAI,cAAc,CAAA;AACtC,oEAAoE;AACpE,wBAAgB,IAAI,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAAA"}

package/dist/builders/data.js

@@ -1,18 +0,0 @@
-// oxlint-disable typescript/no-explicit-any
-import { z } from 'zod';
-import {} from '../grammar/values/data.js';
-// Runtime symbol matching the declared unique symbol
-const DATA_TAG_RUNTIME = Symbol.for('DATA_TAG');
-export function data(target) {
-    const schema = z.unknown();
-    if (target === undefined) {
-        ;
-        schema[DATA_TAG_RUNTIME] = { kind: 'self' };
-    }
-    else {
-        ;
-        schema[DATA_TAG_RUNTIME] = { kind: 'grant', target };
-    }
-    return schema;
-}
-//# sourceMappingURL=data.js.map

package/dist/builders/data.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"data.js","sourceRoot":"","sources":["../../src/builders/data.ts"],"names":[],"mappings":"AAAA,4CAA4C;AAC5C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,OAAO,EAA6C,MAAM,2BAA2B,CAAA;AAErF,qDAAqD;AACrD,MAAM,gBAAgB,GAAG,MAAM,CAAC,GAAG,CAAC,UAAU,CAAoB,CAAA;AAMlE,MAAM,UAAU,IAAI,CAAC,MAAe;IAClC,MAAM,MAAM,GAAG,CAAC,CAAC,OAAO,EAAE,CAAA;IAE1B,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACzB,CAAC;QAAC,MAAc,CAAC,gBAAgB,CAAC,GAAG,EAAE,IAAI,EAAE,MAAe,EAAE,CAAA;IAChE,CAAC;SAAM,CAAC;QACN,CAAC;QAAC,MAAc,CAAC,gBAAgB,CAAC,GAAG,EAAE,IAAI,EAAE,OAAgB,EAAE,MAAM,EAAE,CAAA;IACzE,CAAC;IAED,OAAO,MAAa,CAAA;AACtB,CAAC"}

package/dist/builders/definition/base.d.ts

@@ -1,13 +0,0 @@
-import type { Kind } from '../../grammar/definition/discriminants.js';
-/**
- * Internal factory that tags a config with __kind and __brand.
- * Handles thunk wrapping: if config is a function, it's stored as-is
- * and resolved later during defineSchema().
- */
-export declare function createDef<K extends Kind>(kind: K, config: object): any;
-/**
- * Internal factory for edge definitions.
- * Endpoints are top-level, config is the rest.
- */
-export declare function createEdgeDef<K extends Kind>(kind: K, from: object, to: object, config?: object): any;
-//# sourceMappingURL=base.d.ts.map

package/dist/builders/definition/base.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../src/builders/definition/base.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,2CAA2C,CAAA;AAErE;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,IAAI,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,GAAG,GAAG,CAKtE;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,IAAI,EAC1C,IAAI,EAAE,CAAC,EACP,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,MAAM,CAAC,EAAE,MAAM,GACd,GAAG,CAOL"}

package/dist/builders/definition/base.js

@@ -1,24 +0,0 @@
-/**
- * Internal factory that tags a config with __kind and __brand.
- * Handles thunk wrapping: if config is a function, it's stored as-is
- * and resolved later during defineSchema().
- */
-export function createDef(kind, config) {
-    return {
-        __kind: kind,
-        config,
-    };
-}
-/**
- * Internal factory for edge definitions.
- * Endpoints are top-level, config is the rest.
- */
-export function createEdgeDef(kind, from, to, config) {
-    return {
-        __kind: kind,
-        from,
-        to,
-        config: config ?? {},
-    };
-}
-//# sourceMappingURL=base.js.map

package/dist/builders/definition/base.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"base.js","sourceRoot":"","sources":["../../../src/builders/definition/base.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,MAAM,UAAU,SAAS,CAAiB,IAAO,EAAE,MAAc;IAC/D,OAAO;QACL,MAAM,EAAE,IAAI;QACZ,MAAM;KACP,CAAA;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,aAAa,CAC3B,IAAO,EACP,IAAY,EACZ,EAAU,EACV,MAAe;IAEf,OAAO;QACL,MAAM,EAAE,IAAI;QACZ,IAAI;QACJ,EAAE;QACF,MAAM,EAAE,MAAM,IAAI,EAAE;KACrB,CAAA;AACH,CAAC"}

package/dist/builders/definition/edge-class.d.ts

@@ -1,8 +0,0 @@
-import type { EdgeClassConfig, EdgeClassDef } from '../../grammar/definition/edge-class.js';
-import type { EndpointConfig } from '../../grammar/facets/endpoints.js';
-/**
- * Create an edge class (concrete, has endpoints).
- * Endpoints are positional, config is optional.
- */
-export declare function edgeClass<const From extends EndpointConfig, const To extends EndpointConfig, const C extends EdgeClassConfig>(from: From, to: To, config?: C): EdgeClassDef<From, To, C & EdgeClassConfig>;
-//# sourceMappingURL=edge-class.d.ts.map

package/dist/builders/definition/edge-class.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"edge-class.d.ts","sourceRoot":"","sources":["../../../src/builders/definition/edge-class.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,wCAAwC,CAAA;AAC3F,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAA;AAIvE;;;GAGG;AACH,wBAAgB,SAAS,CACvB,KAAK,CAAC,IAAI,SAAS,cAAc,EACjC,KAAK,CAAC,EAAE,SAAS,cAAc,EAC/B,KAAK,CAAC,CAAC,SAAS,eAAe,EAC/B,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,IAAI,EAAE,EAAE,EAAE,CAAC,GAAG,eAAe,CAAC,CAE7E"}

package/dist/builders/definition/edge-class.js

@@ -1,9 +0,0 @@
-import { createEdgeDef } from './base.js';
-/**
- * Create an edge class (concrete, has endpoints).
- * Endpoints are positional, config is optional.
- */
-export function edgeClass(from, to, config) {
-    return createEdgeDef('edge-class', from, to, config);
-}
-//# sourceMappingURL=edge-class.js.map