@livon/schema 0.27.0-rc.1

package/dist/binary.spec.cjs

@@ -0,0 +1,107 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const external_binary_cjs_namespaceObject = require("./binary.cjs");
+const external_schemaFactory_cjs_namespaceObject = require("./schemaFactory.cjs");
+const external_typeGuards_cjs_namespaceObject = require("./typeGuards.cjs");
+const index_cjs_namespaceObject = require("./testing/mocks/index.cjs");
+external_vitest_namespaceObject.vi.mock('./schemaFactory.js', ()=>({
+        schemaFactory: external_vitest_namespaceObject.vi.fn()
+    }));
+external_vitest_namespaceObject.vi.mock('./typeGuards.js', ()=>({
+        isUint8Array: external_vitest_namespaceObject.vi.fn()
+    }));
+const schemaFactoryMock = external_vitest_namespaceObject.vi.mocked(external_schemaFactory_cjs_namespaceObject.schemaFactory);
+const isUint8ArrayMock = external_vitest_namespaceObject.vi.mocked(external_typeGuards_cjs_namespaceObject.isUint8Array);
+const schemaContextMock = (0, index_cjs_namespaceObject.createSchemaContextMock)();
+const schemaFactoryImplementation = (0, index_cjs_namespaceObject.createSchemaFactoryMock)();
+const getFactoryInput = ()=>{
+    const call = schemaFactoryMock.mock.calls[0];
+    if (!call) throw new Error('schemaFactory should be called once before reading input');
+    return call[0];
+};
+(0, external_vitest_namespaceObject.describe)('binary()', ()=>{
+    (0, external_vitest_namespaceObject.beforeAll)(()=>{
+        schemaFactoryMock.mockImplementation(schemaFactoryImplementation);
+    });
+    (0, external_vitest_namespaceObject.beforeEach)(()=>{
+        schemaFactoryMock.mockClear();
+        schemaFactoryImplementation.mockClear();
+        isUint8ArrayMock.mockReset();
+        isUint8ArrayMock.mockReturnValue(true);
+    });
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        isUint8ArrayMock.mockClear();
+    });
+    (0, external_vitest_namespaceObject.afterAll)(()=>{
+        schemaFactoryMock.mockReset();
+        schemaFactoryImplementation.mockReset();
+        isUint8ArrayMock.mockReset();
+    });
+    (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+        (0, external_vitest_namespaceObject.it)('should delegate to schemaFactory when binary input metadata is provided', ()=>{
+            const result = (0, external_binary_cjs_namespaceObject.binary)({
+                name: 'Attachment'
+            });
+            (0, external_vitest_namespaceObject.expect)(schemaFactoryMock).toHaveBeenCalledTimes(1);
+            const factoryInput = getFactoryInput();
+            (0, external_vitest_namespaceObject.expect)(factoryInput.name).toBe('Attachment');
+            (0, external_vitest_namespaceObject.expect)(factoryInput.type).toBe('binary');
+            (0, external_vitest_namespaceObject.expect)(factoryInput.doc).toBeUndefined();
+            (0, external_vitest_namespaceObject.expect)(factoryInput.ast(schemaContextMock)).toEqual({
+                type: 'binary',
+                name: 'Attachment'
+            });
+            (0, external_vitest_namespaceObject.expect)(result).toBe(schemaFactoryMock.mock.results[0]?.value);
+        });
+        (0, external_vitest_namespaceObject.it)('should pass doc metadata to schemaFactory when doc is provided', ()=>{
+            const doc = {
+                summary: 'binary doc'
+            };
+            (0, external_binary_cjs_namespaceObject.binary)({
+                name: 'Payload',
+                doc
+            });
+            const factoryInput = getFactoryInput();
+            (0, external_vitest_namespaceObject.expect)(factoryInput.name).toBe('Payload');
+            (0, external_vitest_namespaceObject.expect)(factoryInput.doc).toEqual(doc);
+            (0, external_vitest_namespaceObject.expect)(factoryInput.ast(schemaContextMock)).toEqual({
+                type: 'binary',
+                name: 'Payload'
+            });
+        });
+        (0, external_vitest_namespaceObject.it)('should validate input through isUint8Array when input is Uint8Array', ()=>{
+            const input = new Uint8Array([
+                9,
+                8,
+                7
+            ]);
+            (0, external_binary_cjs_namespaceObject.binary)({
+                name: 'Blob'
+            });
+            const factoryInput = getFactoryInput();
+            const parsed = factoryInput.validate(input, schemaContextMock);
+            (0, external_vitest_namespaceObject.expect)(parsed).toBe(input);
+            (0, external_vitest_namespaceObject.expect)(isUint8ArrayMock).toHaveBeenCalledWith(input);
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+        (0, external_vitest_namespaceObject.it)('should throw schema error payload when input is not Uint8Array', ()=>{
+            isUint8ArrayMock.mockReturnValue(false);
+            (0, external_binary_cjs_namespaceObject.binary)({
+                name: 'Blob'
+            });
+            const factoryInput = getFactoryInput();
+            const thrown = (0, index_cjs_namespaceObject.captureThrow)(()=>factoryInput.validate('x', schemaContextMock));
+            (0, external_vitest_namespaceObject.expect)(thrown.threw).toBe(true);
+            (0, external_vitest_namespaceObject.expect)(thrown.value).toEqual({
+                message: 'Expected Uint8Array',
+                code: 'binary.type'
+            });
+        });
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/binary.spec.d.ts

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

package/dist/binary.spec.js

@@ -0,0 +1,101 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { binary } from "./binary.js";
+import { schemaFactory } from "./schemaFactory.js";
+import { isUint8Array } from "./typeGuards.js";
+import { captureThrow, createSchemaContextMock, createSchemaFactoryMock } from "./testing/mocks/index.js";
+vi.mock('./schemaFactory.js', ()=>({
+        schemaFactory: vi.fn()
+    }));
+vi.mock('./typeGuards.js', ()=>({
+        isUint8Array: vi.fn()
+    }));
+const schemaFactoryMock = vi.mocked(schemaFactory);
+const isUint8ArrayMock = vi.mocked(isUint8Array);
+const schemaContextMock = createSchemaContextMock();
+const schemaFactoryImplementation = createSchemaFactoryMock();
+const getFactoryInput = ()=>{
+    const call = schemaFactoryMock.mock.calls[0];
+    if (!call) throw new Error('schemaFactory should be called once before reading input');
+    return call[0];
+};
+describe('binary()', ()=>{
+    beforeAll(()=>{
+        schemaFactoryMock.mockImplementation(schemaFactoryImplementation);
+    });
+    beforeEach(()=>{
+        schemaFactoryMock.mockClear();
+        schemaFactoryImplementation.mockClear();
+        isUint8ArrayMock.mockReset();
+        isUint8ArrayMock.mockReturnValue(true);
+    });
+    afterEach(()=>{
+        isUint8ArrayMock.mockClear();
+    });
+    afterAll(()=>{
+        schemaFactoryMock.mockReset();
+        schemaFactoryImplementation.mockReset();
+        isUint8ArrayMock.mockReset();
+    });
+    describe('happy', ()=>{
+        it('should delegate to schemaFactory when binary input metadata is provided', ()=>{
+            const result = binary({
+                name: 'Attachment'
+            });
+            expect(schemaFactoryMock).toHaveBeenCalledTimes(1);
+            const factoryInput = getFactoryInput();
+            expect(factoryInput.name).toBe('Attachment');
+            expect(factoryInput.type).toBe('binary');
+            expect(factoryInput.doc).toBeUndefined();
+            expect(factoryInput.ast(schemaContextMock)).toEqual({
+                type: 'binary',
+                name: 'Attachment'
+            });
+            expect(result).toBe(schemaFactoryMock.mock.results[0]?.value);
+        });
+        it('should pass doc metadata to schemaFactory when doc is provided', ()=>{
+            const doc = {
+                summary: 'binary doc'
+            };
+            binary({
+                name: 'Payload',
+                doc
+            });
+            const factoryInput = getFactoryInput();
+            expect(factoryInput.name).toBe('Payload');
+            expect(factoryInput.doc).toEqual(doc);
+            expect(factoryInput.ast(schemaContextMock)).toEqual({
+                type: 'binary',
+                name: 'Payload'
+            });
+        });
+        it('should validate input through isUint8Array when input is Uint8Array', ()=>{
+            const input = new Uint8Array([
+                9,
+                8,
+                7
+            ]);
+            binary({
+                name: 'Blob'
+            });
+            const factoryInput = getFactoryInput();
+            const parsed = factoryInput.validate(input, schemaContextMock);
+            expect(parsed).toBe(input);
+            expect(isUint8ArrayMock).toHaveBeenCalledWith(input);
+        });
+    });
+    describe('sad', ()=>{
+        it('should throw schema error payload when input is not Uint8Array', ()=>{
+            isUint8ArrayMock.mockReturnValue(false);
+            binary({
+                name: 'Blob'
+            });
+            const factoryInput = getFactoryInput();
+            const thrown = captureThrow(()=>factoryInput.validate('x', schemaContextMock));
+            expect(thrown.threw).toBe(true);
+            expect(thrown.value).toEqual({
+                message: 'Expected Uint8Array',
+                code: 'binary.type'
+            });
+        });
+    });
+});

package/dist/boolean.cjs

@@ -0,0 +1,53 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    boolean: ()=>boolean_boolean
+});
+const external_schemaFactory_cjs_namespaceObject = require("./schemaFactory.cjs");
+const external_typeGuards_cjs_namespaceObject = require("./typeGuards.cjs");
+const boolean_boolean = ({ name = 'boolean', doc } = {})=>(0, external_schemaFactory_cjs_namespaceObject.schemaFactory)({
+        name,
+        type: 'boolean',
+        doc,
+        ast: ()=>({
+                type: 'boolean',
+                name
+            }),
+        validate: (input)=>{
+            if (!(0, external_typeGuards_cjs_namespaceObject.isBoolean)(input)) throw {
+                message: 'Data is not a boolean',
+                code: 'boolean.type'
+            };
+            return input;
+        }
+    });
+exports.boolean = __webpack_exports__.boolean;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "boolean"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/boolean.d.ts

@@ -0,0 +1,24 @@
+import type { SchemaDoc } from './types.js';
+export interface BooleanFactoryInput {
+    name?: string;
+    doc?: SchemaDoc;
+}
+/**
+ * boolean is part of the public LIVON API.
+ *
+ * @remarks
+ * Parameter and return types are defined in the TypeScript signature.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/schema/boolean
+ *
+ * @example
+ * // Creates a boolean schema and validates a true value.
+ * const IsActive = boolean();
+ * IsActive.parse(true);
+ *
+ * @example
+ * // Extends boolean validation to also allow undefined.
+ * const MaybeIsActive = boolean().optional();
+ * MaybeIsActive.parse(undefined);
+ */
+export declare const boolean: ({ name, doc }?: BooleanFactoryInput) => import("./schemaFactory.js").SchemaWithChain<boolean, import("./schemaFactory.js").SchemaFactoryChainDefinition<boolean>>;

package/dist/boolean.js

@@ -0,0 +1,19 @@
+import { schemaFactory } from "./schemaFactory.js";
+import { isBoolean } from "./typeGuards.js";
+const boolean_boolean = ({ name = 'boolean', doc } = {})=>schemaFactory({
+        name,
+        type: 'boolean',
+        doc,
+        ast: ()=>({
+                type: 'boolean',
+                name
+            }),
+        validate: (input)=>{
+            if (!isBoolean(input)) throw {
+                message: 'Data is not a boolean',
+                code: 'boolean.type'
+            };
+            return input;
+        }
+    });
+export { boolean_boolean as boolean };

package/dist/boolean.spec.cjs

@@ -0,0 +1,96 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const external_boolean_cjs_namespaceObject = require("./boolean.cjs");
+const external_schemaFactory_cjs_namespaceObject = require("./schemaFactory.cjs");
+const external_typeGuards_cjs_namespaceObject = require("./typeGuards.cjs");
+const index_cjs_namespaceObject = require("./testing/mocks/index.cjs");
+external_vitest_namespaceObject.vi.mock('./schemaFactory.js', ()=>({
+        schemaFactory: external_vitest_namespaceObject.vi.fn()
+    }));
+external_vitest_namespaceObject.vi.mock('./typeGuards.js', ()=>({
+        isBoolean: external_vitest_namespaceObject.vi.fn()
+    }));
+const schemaFactoryMock = external_vitest_namespaceObject.vi.mocked(external_schemaFactory_cjs_namespaceObject.schemaFactory);
+const isBooleanMock = external_vitest_namespaceObject.vi.mocked(external_typeGuards_cjs_namespaceObject.isBoolean);
+const schemaContextMock = (0, index_cjs_namespaceObject.createSchemaContextMock)();
+const schemaFactoryImplementation = (0, index_cjs_namespaceObject.createSchemaFactoryMock)();
+const getFactoryInput = ()=>{
+    const call = schemaFactoryMock.mock.calls[0];
+    if (!call) throw new Error('schemaFactory should be called once before reading input');
+    return call[0];
+};
+(0, external_vitest_namespaceObject.describe)('boolean()', ()=>{
+    (0, external_vitest_namespaceObject.beforeAll)(()=>{
+        schemaFactoryMock.mockImplementation(schemaFactoryImplementation);
+    });
+    (0, external_vitest_namespaceObject.beforeEach)(()=>{
+        schemaFactoryMock.mockClear();
+        schemaFactoryImplementation.mockClear();
+        isBooleanMock.mockReset();
+        isBooleanMock.mockReturnValue(true);
+    });
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        isBooleanMock.mockClear();
+    });
+    (0, external_vitest_namespaceObject.afterAll)(()=>{
+        schemaFactoryMock.mockReset();
+        schemaFactoryImplementation.mockReset();
+        isBooleanMock.mockReset();
+    });
+    (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+        (0, external_vitest_namespaceObject.it)('should delegate to schemaFactory when using default metadata', ()=>{
+            const result = (0, external_boolean_cjs_namespaceObject.boolean)();
+            (0, external_vitest_namespaceObject.expect)(schemaFactoryMock).toHaveBeenCalledTimes(1);
+            const factoryInput = getFactoryInput();
+            (0, external_vitest_namespaceObject.expect)(factoryInput.name).toBe('boolean');
+            (0, external_vitest_namespaceObject.expect)(factoryInput.type).toBe('boolean');
+            (0, external_vitest_namespaceObject.expect)(factoryInput.doc).toBeUndefined();
+            (0, external_vitest_namespaceObject.expect)(factoryInput.ast(schemaContextMock)).toEqual({
+                type: 'boolean',
+                name: 'boolean'
+            });
+            (0, external_vitest_namespaceObject.expect)(result).toBe(schemaFactoryMock.mock.results[0]?.value);
+        });
+        (0, external_vitest_namespaceObject.it)('should pass custom metadata to schemaFactory when options are provided', ()=>{
+            const doc = {
+                summary: 'bool doc'
+            };
+            (0, external_boolean_cjs_namespaceObject.boolean)({
+                name: 'Flag',
+                doc
+            });
+            const factoryInput = getFactoryInput();
+            (0, external_vitest_namespaceObject.expect)(factoryInput.name).toBe('Flag');
+            (0, external_vitest_namespaceObject.expect)(factoryInput.doc).toEqual(doc);
+            (0, external_vitest_namespaceObject.expect)(factoryInput.ast(schemaContextMock)).toEqual({
+                type: 'boolean',
+                name: 'Flag'
+            });
+        });
+        (0, external_vitest_namespaceObject.it)('should validate input through isBoolean when input is boolean', ()=>{
+            (0, external_boolean_cjs_namespaceObject.boolean)();
+            const factoryInput = getFactoryInput();
+            const parsed = factoryInput.validate(true, schemaContextMock);
+            (0, external_vitest_namespaceObject.expect)(parsed).toBe(true);
+            (0, external_vitest_namespaceObject.expect)(isBooleanMock).toHaveBeenCalledWith(true);
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+        (0, external_vitest_namespaceObject.it)('should throw schema error payload when input is not a boolean', ()=>{
+            isBooleanMock.mockReturnValue(false);
+            (0, external_boolean_cjs_namespaceObject.boolean)();
+            const factoryInput = getFactoryInput();
+            const thrown = (0, index_cjs_namespaceObject.captureThrow)(()=>factoryInput.validate('x', schemaContextMock));
+            (0, external_vitest_namespaceObject.expect)(thrown.threw).toBe(true);
+            (0, external_vitest_namespaceObject.expect)(thrown.value).toEqual({
+                message: 'Data is not a boolean',
+                code: 'boolean.type'
+            });
+        });
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/boolean.spec.d.ts

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

package/dist/boolean.spec.js

@@ -0,0 +1,90 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { boolean as external_boolean_js_boolean } from "./boolean.js";
+import { schemaFactory } from "./schemaFactory.js";
+import { isBoolean } from "./typeGuards.js";
+import { captureThrow, createSchemaContextMock, createSchemaFactoryMock } from "./testing/mocks/index.js";
+vi.mock('./schemaFactory.js', ()=>({
+        schemaFactory: vi.fn()
+    }));
+vi.mock('./typeGuards.js', ()=>({
+        isBoolean: vi.fn()
+    }));
+const schemaFactoryMock = vi.mocked(schemaFactory);
+const isBooleanMock = vi.mocked(isBoolean);
+const schemaContextMock = createSchemaContextMock();
+const schemaFactoryImplementation = createSchemaFactoryMock();
+const getFactoryInput = ()=>{
+    const call = schemaFactoryMock.mock.calls[0];
+    if (!call) throw new Error('schemaFactory should be called once before reading input');
+    return call[0];
+};
+describe('boolean()', ()=>{
+    beforeAll(()=>{
+        schemaFactoryMock.mockImplementation(schemaFactoryImplementation);
+    });
+    beforeEach(()=>{
+        schemaFactoryMock.mockClear();
+        schemaFactoryImplementation.mockClear();
+        isBooleanMock.mockReset();
+        isBooleanMock.mockReturnValue(true);
+    });
+    afterEach(()=>{
+        isBooleanMock.mockClear();
+    });
+    afterAll(()=>{
+        schemaFactoryMock.mockReset();
+        schemaFactoryImplementation.mockReset();
+        isBooleanMock.mockReset();
+    });
+    describe('happy', ()=>{
+        it('should delegate to schemaFactory when using default metadata', ()=>{
+            const result = external_boolean_js_boolean();
+            expect(schemaFactoryMock).toHaveBeenCalledTimes(1);
+            const factoryInput = getFactoryInput();
+            expect(factoryInput.name).toBe('boolean');
+            expect(factoryInput.type).toBe('boolean');
+            expect(factoryInput.doc).toBeUndefined();
+            expect(factoryInput.ast(schemaContextMock)).toEqual({
+                type: 'boolean',
+                name: 'boolean'
+            });
+            expect(result).toBe(schemaFactoryMock.mock.results[0]?.value);
+        });
+        it('should pass custom metadata to schemaFactory when options are provided', ()=>{
+            const doc = {
+                summary: 'bool doc'
+            };
+            external_boolean_js_boolean({
+                name: 'Flag',
+                doc
+            });
+            const factoryInput = getFactoryInput();
+            expect(factoryInput.name).toBe('Flag');
+            expect(factoryInput.doc).toEqual(doc);
+            expect(factoryInput.ast(schemaContextMock)).toEqual({
+                type: 'boolean',
+                name: 'Flag'
+            });
+        });
+        it('should validate input through isBoolean when input is boolean', ()=>{
+            external_boolean_js_boolean();
+            const factoryInput = getFactoryInput();
+            const parsed = factoryInput.validate(true, schemaContextMock);
+            expect(parsed).toBe(true);
+            expect(isBooleanMock).toHaveBeenCalledWith(true);
+        });
+    });
+    describe('sad', ()=>{
+        it('should throw schema error payload when input is not a boolean', ()=>{
+            isBooleanMock.mockReturnValue(false);
+            external_boolean_js_boolean();
+            const factoryInput = getFactoryInput();
+            const thrown = captureThrow(()=>factoryInput.validate('x', schemaContextMock));
+            expect(thrown.threw).toBe(true);
+            expect(thrown.value).toEqual({
+                message: 'Data is not a boolean',
+                code: 'boolean.type'
+            });
+        });
+    });
+});

package/dist/context.cjs

@@ -0,0 +1,125 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createBuilder: ()=>createBuilder,
+    createSchemaContext: ()=>createSchemaContext,
+    createState: ()=>createState,
+    isNormalizedRequest: ()=>isNormalizedRequest,
+    normalizeBuildContext: ()=>normalizeBuildContext,
+    normalizeRequestContext: ()=>normalizeRequestContext
+});
+const createBuilder = ()=>{
+    const nodes = [];
+    return {
+        add: (node)=>{
+            nodes.push(node);
+            return node;
+        },
+        getAll: ()=>nodes
+    };
+};
+const createState = ()=>{
+    const store = new Map();
+    return {
+        get: (key)=>store.get(key),
+        set: (key, value)=>{
+            store.set(key, value);
+        },
+        update: (key, updater)=>{
+            const next = updater(store.get(key));
+            store.set(key, next);
+        },
+        snapshot: ()=>Array.from(store.entries()).reduce((acc, [key, value])=>{
+                acc[key] = value;
+                return acc;
+            }, {})
+    };
+};
+const normalizeBuildContext = (input = {})=>({
+        buildId: input.buildId ?? `${Date.now()}-${Math.random().toString(16).slice(2)}`,
+        builder: input.builder ?? createBuilder(),
+        parentNode: input.parentNode,
+        schemaPath: input.schemaPath ?? [],
+        buildOptions: input.buildOptions ?? {}
+    });
+const isNormalizedRequest = (input)=>true === input.normalized;
+const normalizeRequestContext = (input = {})=>{
+    if (isNormalizedRequest(input)) return input;
+    return {
+        normalized: true,
+        requestId: input.requestId ?? `${Date.now()}-${Math.random().toString(16).slice(2)}`,
+        timestamp: input.timestamp ?? Date.now(),
+        correlationId: input.correlationId,
+        sourceId: input.sourceId,
+        userId: input.userId,
+        tenantId: input.tenantId,
+        metadata: input.metadata,
+        state: createState(),
+        publisher: input.publisher,
+        onPublishError: input.onPublishError,
+        logger: input.logger
+    };
+};
+const createSchemaContext = (input = {})=>{
+    let buildContext = input.build ? normalizeBuildContext(input.build) : void 0;
+    let requestContext = input.request ? normalizeRequestContext(input.request) : void 0;
+    const state = requestContext?.state ?? createState();
+    return {
+        getBuildContext: ()=>buildContext,
+        setBuildContext: (next)=>{
+            buildContext = next;
+        },
+        getRequestContext: ()=>requestContext,
+        get request () {
+            return requestContext;
+        },
+        setRequestContext: (next)=>{
+            requestContext = next ? normalizeRequestContext(next) : void 0;
+            if (requestContext && requestContext.state !== state) requestContext = {
+                ...requestContext,
+                state
+            };
+        },
+        state
+    };
+};
+exports.createBuilder = __webpack_exports__.createBuilder;
+exports.createSchemaContext = __webpack_exports__.createSchemaContext;
+exports.createState = __webpack_exports__.createState;
+exports.isNormalizedRequest = __webpack_exports__.isNormalizedRequest;
+exports.normalizeBuildContext = __webpack_exports__.normalizeBuildContext;
+exports.normalizeRequestContext = __webpack_exports__.normalizeRequestContext;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createBuilder",
+    "createSchemaContext",
+    "createState",
+    "isNormalizedRequest",
+    "normalizeBuildContext",
+    "normalizeRequestContext"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});