@kamilio/wire 0.1.9 → 0.1.10

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/standard.d.ts

@@ -0,0 +1,92 @@
+import { type AnySchema, type Static } from "./index.js";
+import { nativeJsonSchema } from "./native-json-schema.js";
+/** Structural Standard Schema / Standard JSON Schema v1 contracts. No runtime dependency. */
+export interface StandardIssue {
+    readonly message: string;
+    readonly path?: ReadonlyArray<PropertyKey | {
+        readonly key: PropertyKey;
+    }>;
+}
+export type StandardResult<T> = {
+    readonly value: T;
+    readonly issues?: undefined;
+} | {
+    readonly issues: readonly StandardIssue[];
+    readonly value?: undefined;
+};
+export interface StandardSchema<Input = unknown, Output = Input> {
+    readonly "~standard": {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly types?: {
+            readonly input: Input;
+            readonly output: Output;
+        };
+        readonly validate: (value: unknown, options?: {
+            readonly libraryOptions?: Record<string, unknown>;
+        }) => StandardResult<Output> | Promise<StandardResult<Output>>;
+        readonly jsonSchema: {
+            readonly input: (options: StandardJsonSchemaOptions) => Record<string, unknown>;
+            readonly output: (options: StandardJsonSchemaOptions) => Record<string, unknown>;
+        };
+    };
+}
+export interface StandardJsonSchemaOptions {
+    readonly target: string;
+    readonly libraryOptions?: Record<string, unknown>;
+}
+export type Input<T extends AnySchema> = Static<T>;
+type HasDefault<T> = AnySchema extends T ? false : T extends {
+    readonly inner: infer Inner;
+} ? HasDefault<Inner> : T extends {
+    readonly default: infer Value;
+} ? undefined extends Value ? false : true : false;
+type OptionalOutputKeys<Shape> = {
+    [K in keyof Shape]: Shape[K] extends {
+        readonly kind: "optional";
+    } ? HasDefault<Shape[K]> extends true ? never : K : never;
+}[keyof Shape];
+type ObjectOutput<Shape extends Record<string, AnySchema>> = {
+    [K in Exclude<keyof Shape, OptionalOutputKeys<Shape>>]: Output<Shape[K]>;
+} & {
+    [K in OptionalOutputKeys<Shape>]?: Output<Shape[K]>;
+};
+type OutputValue<T extends AnySchema> = T extends {
+    readonly [nativeJsonSchema]: unknown;
+} ? Static<T> : T extends {
+    readonly kind: "object";
+    readonly shape: infer Shape extends Record<string, AnySchema>;
+} ? ObjectOutput<Shape> : T extends {
+    readonly kind: "array";
+    readonly item: infer Item extends AnySchema;
+} ? Output<Item>[] : T extends {
+    readonly kind: "record";
+    readonly value: infer Value extends AnySchema;
+} ? Record<string, Output<Value>> : T extends {
+    readonly kind: "optional";
+    readonly inner: infer Inner extends AnySchema;
+} ? Output<Inner> | (HasDefault<Inner> extends true ? never : undefined) : T extends {
+    readonly kind: "union";
+    readonly branches: infer Branches extends readonly AnySchema[];
+} ? Output<Branches[number]> : T extends {
+    readonly kind: "oneOf";
+    readonly branches: infer Branches extends Record<string, AnySchema>;
+    readonly discriminator: infer Key extends string;
+} ? {
+    [Name in keyof Branches & string]: Output<Branches[Name]> & Record<Key, Name>;
+}[keyof Branches & string] : Static<T>;
+export type Output<T extends AnySchema> = 0 extends (1 & T) ? any : AnySchema extends T ? Static<T> : T extends {
+    readonly "~standard": {
+        readonly types?: {
+            readonly output: infer Value;
+        };
+    };
+} ? Value : OutputValue<T> | (T extends {
+    readonly nullable: true;
+} ? null : never);
+export type Standardized<T extends AnySchema> = T extends unknown ? (T extends StandardSchema ? Omit<T, "~standard"> : T) & StandardSchema<Input<T>, OutputValue<T> | (T extends {
+    readonly nullable: true;
+} ? null : never)> : never;
+/** Attach interoperable methods without changing the enumerable descriptor or its JSON form. */
+export declare function withStandardSchema<T extends AnySchema>(schema: T): Standardized<T>;
+export {};

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/standard.js

@@ -0,0 +1,38 @@
+import { toJsonSchema } from "./index.js";
+import { validate } from "./validate.js";
+import { nativeJsonSchema } from "./native-json-schema.js";
+function standardDocument(schema, io, options) {
+    const uri = options.target === "draft-2020-12" ? "https://json-schema.org/draft/2020-12/schema"
+        : options.target === "draft-07" ? "http://json-schema.org/draft-07/schema#" : undefined;
+    if (uri === undefined)
+        throw new Error(`Unsupported JSON Schema target: ${options.target}`);
+    const document = toJsonSchema(schema, { io, target: options.target });
+    if (document.$schema !== undefined && document.$schema !== uri && document.$schema !== (uri.endsWith("#") ? uri.slice(0, -1) : uri)) {
+        throw new Error(`Native JSON Schema dialect does not match target: ${options.target}`);
+    }
+    if ((schema.kind === "oneOf" || schema.kind === "union") && schema.nullable !== true)
+        document.type = "object";
+    return { $schema: uri, ...document };
+}
+/** Attach interoperable methods without changing the enumerable descriptor or its JSON form. */
+export function withStandardSchema(schema) {
+    Object.defineProperty(schema, "~standard", {
+        configurable: true,
+        get() {
+            const descriptor = this;
+            return {
+                version: 1,
+                vendor: "toolcraft-schema",
+                validate(value) {
+                    const result = validate(descriptor, value);
+                    return result.ok ? { value: result.value } : { issues: result.issues };
+                },
+                jsonSchema: {
+                    input: (options) => standardDocument(descriptor, "input", options),
+                    output: (options) => standardDocument(descriptor, "output", options)
+                }
+            };
+        }
+    });
+    return schema;
+}

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/union.compile-check.d.ts

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

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/union.compile-check.js

@@ -0,0 +1,9 @@
+import { S } from "./index.js";
+const ignoredSchema = S.Union([
+    S.Object({
+        email: S.String(),
+    }),
+    S.Object({
+        phone: S.String(),
+    }),
+]);

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/union.d.ts

@@ -0,0 +1,9 @@
+import { type Standardized } from "./standard.js";
+import type { ObjectSchema, SchemaBase, Static } from "./index.js";
+type UnionStatic<TBranches extends readonly ObjectSchema<any>[]> = Static<TBranches[number]>;
+export interface UnionSchema<TBranches extends readonly ObjectSchema<any>[]> extends SchemaBase<"union", UnionStatic<TBranches>> {
+    readonly branches: TBranches;
+}
+export declare function getRequiredKeyFingerprint(schema: ObjectSchema<any>): string;
+export declare function Union<const TBranches extends readonly ObjectSchema<any>[]>(branches: TBranches): Standardized<UnionSchema<TBranches>>;
+export {};

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/union.js

@@ -0,0 +1,46 @@
+import { withStandardSchema } from "./standard.js";
+function isOptionalSchema(schema) {
+    return schema.kind === "optional";
+}
+function getRequiredKeys(schema) {
+    return Object.keys(schema.shape)
+        .filter((key) => !isOptionalSchema(schema.shape[key]))
+        .sort();
+}
+export function getRequiredKeyFingerprint(schema) {
+    return getRequiredKeys(schema).join("+");
+}
+function assertUniqueRequiredKeyFingerprints(branches) {
+    const fingerprints = new Map();
+    branches.forEach((branch, index) => {
+        const requiredKeys = getRequiredKeys(branch);
+        const fingerprint = JSON.stringify(requiredKeys);
+        const existing = fingerprints.get(fingerprint);
+        if (existing === undefined) {
+            fingerprints.set(fingerprint, {
+                display: requiredKeys.join("+"),
+                indices: [index],
+            });
+            return;
+        }
+        existing.indices.push(index);
+    });
+    for (const { display, indices } of fingerprints.values()) {
+        if (indices.length > 1) {
+            throw new Error(`Union branches [${indices.join(", ")}] share required-key fingerprint "${display}". Each branch must require a distinct set of keys.`);
+        }
+    }
+}
+function assertValidBranches(branches) {
+    if (branches.length === 0) {
+        throw new Error("Union schema requires at least one branch");
+    }
+    assertUniqueRequiredKeyFingerprints(branches);
+}
+export function Union(branches) {
+    assertValidBranches(branches);
+    return withStandardSchema({
+        kind: "union",
+        branches,
+    });
+}

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/validate.d.ts

@@ -0,0 +1,21 @@
+import type { AnySchema, Static } from "./index.js";
+export type SchemaDescriptor = AnySchema;
+export type ValidationIssue = {
+    path: readonly string[];
+    expected: string;
+    received: string;
+    message: string;
+    keyword?: string;
+};
+export type ValidationResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    issues: readonly ValidationIssue[];
+};
+export interface ValidationOptions {
+    defaults?: "none" | "optional" | "all";
+}
+export declare function validate<S extends SchemaDescriptor>(schema: S, value: unknown, options?: ValidationOptions): ValidationResult<Static<S>>;
+export declare function isPlainRecord(value: unknown): value is Record<string, unknown>;

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/validate.js

@@ -0,0 +1,393 @@
+import { cloneDefaultValue } from "./clone-default.js";
+import { isJsonValue } from "./json.js";
+import { deepEqual, unicodeLength } from "./json-schema/utils.js";
+import { getRequiredKeyFingerprint } from "./union.js";
+import { nativeJsonSchema } from "./native-json-schema.js";
+const missingValue = Symbol("missingValue");
+export function validate(schema, value, options = {}) {
+    const state = { issues: [], defaults: options.defaults ?? "optional" };
+    const result = walkSchema(schema, value, [], state);
+    if (state.issues.length > 0) {
+        return { ok: false, issues: state.issues };
+    }
+    return { ok: true, value: (result.present ? result.value : undefined) };
+}
+function walkSchema(schema, value, path, state) {
+    if (schema.kind === "optional") {
+        return walkOptional(schema, value, path, state);
+    }
+    if (value === missingValue && state.defaults === "all" && schema.default !== undefined) {
+        value = cloneDefaultValue(schema.default);
+    }
+    if (value === missingValue) {
+        addIssue(state, path, expectedFor(schema), "missing", `Expected ${expectedFor(schema)} at ${formatPath(path)}`);
+        return { present: false };
+    }
+    const native = schema[nativeJsonSchema];
+    if (native !== undefined) {
+        if (!isJsonValue(value)) {
+            addExpectedIssue(state, path, "JSON value", value);
+        }
+        else {
+            const result = native.validator.validate(value);
+            if (!result.ok)
+                state.issues.push(...result.issues.map((issue) => ({ ...issue, path: [...path, ...issue.path] })));
+        }
+        return { present: true, value };
+    }
+    if (value === null && schema.nullable === true) {
+        return { present: true, value };
+    }
+    switch (schema.kind) {
+        case "string":
+            return walkString(schema, value, path, state);
+        case "number":
+            return walkNumber(schema, value, path, state);
+        case "boolean":
+            return walkBoolean(value, path, state);
+        case "enum":
+            return walkEnum(schema, value, path, state);
+        case "array":
+            return walkArray(schema, value, path, state);
+        case "object":
+            return walkObject(schema, value, path, state);
+        case "oneOf":
+            return walkOneOf(schema, value, path, state);
+        case "union":
+            return walkUnion(schema, value, path, state);
+        case "record":
+            return walkRecord(schema, value, path, state);
+        case "json":
+            return walkJson(schema, value, path, state);
+    }
+}
+function walkOptional(schema, value, path, state) {
+    if (value === missingValue || value === undefined) {
+        if (state.defaults === "none") {
+            return { present: false };
+        }
+        const defaultValue = getDefault(schema.inner);
+        if (defaultValue.present) {
+            let clonedDefault;
+            try {
+                clonedDefault = structuredClone(defaultValue.value);
+            }
+            catch (error) {
+                if (!(error instanceof Error) || error.name !== "DataCloneError")
+                    throw error;
+                clonedDefault = cloneDefaultValue(defaultValue.value);
+            }
+            return walkSchema(schema.inner, clonedDefault, path, state);
+        }
+        return { present: false };
+    }
+    return walkSchema(schema.inner, value, path, state);
+}
+function walkString(schema, value, path, state) {
+    if (typeof value !== "string") {
+        addExpectedIssue(state, path, "string", value);
+        return { present: true, value };
+    }
+    const length = unicodeLength(value);
+    if (schema.minLength !== undefined && length < schema.minLength) {
+        const expected = `string with length at least ${schema.minLength}`;
+        addIssue(state, path, expected, `string with length ${length}`, `Expected ${expected} at ${formatPath(path)}`);
+    }
+    if (schema.maxLength !== undefined && length > schema.maxLength) {
+        const expected = `string with length at most ${schema.maxLength}`;
+        addIssue(state, path, expected, `string with length ${length}`, `Expected ${expected} at ${formatPath(path)}`);
+    }
+    if (schema.pattern !== undefined) {
+        const pattern = compilePattern(schema.pattern);
+        if (pattern === undefined || !pattern.test(value)) {
+            const expected = `string matching pattern ${schema.pattern}`;
+            addIssue(state, path, expected, value, `Expected ${expected} at ${formatPath(path)}`);
+        }
+    }
+    return { present: true, value };
+}
+function walkNumber(schema, value, path, state) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        addExpectedIssue(state, path, schema.jsonType === "integer" ? "integer" : "number", value);
+        return { present: true, value };
+    }
+    if (schema.jsonType === "integer" && !Number.isInteger(value)) {
+        addExpectedIssue(state, path, "integer", value);
+    }
+    if (schema.minimum !== undefined && value < schema.minimum) {
+        const expected = `number greater than or equal to ${schema.minimum}`;
+        addIssue(state, path, expected, String(value), `Expected ${expected} at ${formatPath(path)}`);
+    }
+    if (schema.maximum !== undefined && value > schema.maximum) {
+        const expected = `number less than or equal to ${schema.maximum}`;
+        addIssue(state, path, expected, String(value), `Expected ${expected} at ${formatPath(path)}`);
+    }
+    return { present: true, value };
+}
+function walkBoolean(value, path, state) {
+    if (typeof value !== "boolean") {
+        addExpectedIssue(state, path, "boolean", value);
+    }
+    return { present: true, value };
+}
+function walkEnum(schema, value, path, state) {
+    if (!schema.values.includes(value)) {
+        const expected = `one of ${schema.values.join(", ")}`;
+        addIssue(state, path, expected, receivedValue(value), `Expected ${expected} at ${formatPath(path)}`);
+    }
+    return { present: true, value };
+}
+function walkArray(schema, value, path, state) {
+    if (!Array.isArray(value)) {
+        addExpectedIssue(state, path, "array", value);
+        return { present: true, value };
+    }
+    if (schema.minItems !== undefined && value.length < schema.minItems) {
+        const expected = `array with at least ${schema.minItems} items`;
+        addIssue(state, path, expected, `array with ${value.length} items`, `Expected ${expected} at ${formatPath(path)}`);
+    }
+    if (schema.maxItems !== undefined && value.length > schema.maxItems) {
+        const expected = `array with at most ${schema.maxItems} items`;
+        addIssue(state, path, expected, `array with ${value.length} items`, `Expected ${expected} at ${formatPath(path)}`);
+    }
+    const nextValue = Array.from({ length: value.length }, (_item, index) => {
+        const item = value[index];
+        const result = walkSchema(schema.item, item, [...path, String(index)], state);
+        return result.present ? result.value : item;
+    });
+    return { present: true, value: nextValue };
+}
+function walkObject(schema, value, path, state, injectedProperties = {}) {
+    if (!isPlainRecord(value)) {
+        addExpectedIssue(state, path, "object", value);
+        return { present: true, value };
+    }
+    const nextValue = {};
+    const allowedKeys = new Set([...Object.keys(schema.shape), ...Object.keys(injectedProperties)]);
+    for (const [key, propertySchema] of Object.entries(schema.shape)) {
+        const propertyValue = Object.hasOwn(value, key) ? value[key] : missingValue;
+        const result = walkSchema(propertySchema, propertyValue, [...path, key], state);
+        if (result.present) {
+            setOwnValue(nextValue, key, result.value);
+        }
+    }
+    for (const [key, injectedValue] of Object.entries(injectedProperties)) {
+        if (Object.hasOwn(value, key)) {
+            setOwnValue(nextValue, key, value[key]);
+        }
+        else {
+            setOwnValue(nextValue, key, injectedValue);
+        }
+    }
+    for (const [key, propertyValue] of Object.entries(value)) {
+        if (allowedKeys.has(key)) {
+            continue;
+        }
+        if (schema.additionalProperties === true) {
+            setOwnValue(nextValue, key, propertyValue);
+        }
+        else {
+            addUnexpectedPropertyIssue(state, [...path, key]);
+        }
+    }
+    return { present: true, value: nextValue };
+}
+function walkOneOf(schema, value, path, state) {
+    if (!isPlainRecord(value)) {
+        addExpectedIssue(state, path, "object", value);
+        return { present: true, value };
+    }
+    const discriminatorValue = value[schema.discriminator];
+    const discriminatorPath = [...path, schema.discriminator];
+    const branchValues = Object.keys(schema.branches);
+    const expected = `one of ${branchValues.join(", ")}`;
+    if (!Object.hasOwn(value, schema.discriminator)) {
+        addIssueWithMessage(state, discriminatorPath, expected, "missing", `Missing discriminator "${schema.discriminator}" at ${formatPath(path)}. Expected one of: ${branchValues.join(", ")}.`);
+        return { present: true, value };
+    }
+    if (typeof discriminatorValue !== "string" ||
+        !Object.hasOwn(schema.branches, discriminatorValue)) {
+        addIssueWithMessage(state, discriminatorPath, expected, receivedValue(discriminatorValue), `Expected ${expected} at ${formatPath(discriminatorPath)}, got ${formatReceivedDiscriminator(discriminatorValue)}`);
+        return { present: true, value };
+    }
+    return walkObject(schema.branches[discriminatorValue], value, path, state, {
+        [schema.discriminator]: discriminatorValue
+    });
+}
+function walkUnion(schema, value, path, state) {
+    if (!isPlainRecord(value)) {
+        addExpectedIssue(state, path, "object", value);
+        return { present: true, value };
+    }
+    const candidateBranches = schema.branches.filter((branch) => hasRequiredKeys(branch, value));
+    if (candidateBranches.length === 1 && state.defaults !== "all") {
+        return walkObject(candidateBranches[0], value, path, state);
+    }
+    const matches = [];
+    for (const branch of schema.branches) {
+        const branchState = { ...state, issues: [] };
+        const result = walkObject(branch, value, path, branchState);
+        if (branchState.issues.length === 0 && result.present) {
+            matches.push({ fingerprint: getRequiredKeyFingerprint(branch), value: result.value });
+        }
+    }
+    if (matches.length === 1) {
+        return { present: true, value: matches[0].value };
+    }
+    if (matches.length === 0) {
+        const branchDescriptions = schema.branches.map((branch) => getRequiredKeyFingerprint(branch));
+        addIssueWithMessage(state, path, "exactly one union branch", "0 matching branches", `No union branch matched at ${formatPath(path)}. Tried ${schema.branches.length} branches. Expected one of: ${branchDescriptions.join(" | ")}.`);
+        return { present: true, value };
+    }
+    addIssueWithMessage(state, path, "exactly one union branch", `${matches.length} matching branches`, `Expected exactly one union branch at ${formatPath(path)}, but matched more than one branch: ${matches.map((match) => match.fingerprint).join(" | ")}`);
+    return { present: true, value };
+}
+function hasRequiredKeys(schema, value) {
+    for (const [key, propertySchema] of Object.entries(schema.shape)) {
+        if (propertySchema.kind !== "optional" && !Object.hasOwn(value, key)) {
+            return false;
+        }
+    }
+    return true;
+}
+function walkRecord(schema, value, path, state) {
+    if (!isPlainRecord(value)) {
+        addExpectedIssue(state, path, "object", value);
+        return { present: true, value };
+    }
+    const nextValue = {};
+    for (const [key, propertyValue] of Object.entries(value)) {
+        const result = walkSchema(schema.value, propertyValue, [...path, key], state);
+        if (result.present) {
+            setOwnValue(nextValue, key, result.value);
+        }
+    }
+    return { present: true, value: nextValue };
+}
+function walkJson(schema, value, path, state) {
+    if (isJsonValue(value)) {
+        if (schema.const !== undefined && !deepEqual(value, schema.const)) {
+            addExpectedIssue(state, path, "declared JSON constant", value);
+        }
+        if (schema.enum !== undefined && !schema.enum.some((candidate) => deepEqual(value, candidate))) {
+            addExpectedIssue(state, path, "declared JSON enum value", value);
+        }
+        return { present: true, value };
+    }
+    addExpectedIssue(state, path, "JSON value", value);
+    return { present: true, value };
+}
+function getDefault(schema) {
+    if (schema.default !== undefined) {
+        return { present: true, value: schema.default };
+    }
+    if (schema.kind === "optional") {
+        return getDefault(schema.inner);
+    }
+    return { present: false };
+}
+export function isPlainRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function setOwnValue(target, key, value) {
+    Object.defineProperty(target, key, {
+        configurable: true,
+        enumerable: true,
+        writable: true,
+        value
+    });
+}
+function expectedFor(schema) {
+    switch (schema.kind) {
+        case "string":
+            return "string";
+        case "number":
+            return schema.jsonType === "integer" ? "integer" : "number";
+        case "boolean":
+            return "boolean";
+        case "enum":
+            return `one of ${schema.values.join(", ")}`;
+        case "array":
+            return "array";
+        case "object":
+        case "oneOf":
+        case "record":
+            return "object";
+        case "union":
+            return "exactly one union branch";
+        case "json":
+            return "JSON value";
+        case "optional":
+            return expectedFor(schema.inner);
+    }
+}
+function addExpectedIssue(state, path, expected, value) {
+    addIssue(state, path, expected, receivedType(value), `Expected ${expected} at ${formatPath(path)}`);
+}
+function addUnexpectedPropertyIssue(state, path) {
+    addIssue(state, path, "no additional properties", "unknown property", `Unexpected property ${formatPath(path)}`);
+}
+function addIssue(state, path, expected, received, _message) {
+    state.issues.push({
+        path,
+        expected,
+        received,
+        message: formatIssueMessage(expected, path, received)
+    });
+}
+function addIssueWithMessage(state, path, expected, received, message) {
+    state.issues.push({
+        path,
+        expected,
+        received,
+        message
+    });
+}
+function formatIssueMessage(expected, path, received) {
+    return `Expected ${expected} at ${formatPath(path)}, got ${received}`;
+}
+function formatPath(path) {
+    return path.length === 0 ? "value" : path.join(".");
+}
+function compilePattern(pattern) {
+    try {
+        return new RegExp(pattern);
+    }
+    catch {
+        return undefined;
+    }
+}
+function receivedType(value) {
+    if (value === null) {
+        return "null";
+    }
+    if (Array.isArray(value)) {
+        return "array";
+    }
+    if (typeof value === "object" && !isPlainRecord(value)) {
+        return "non-plain object";
+    }
+    if (typeof value === "number" && Number.isInteger(value)) {
+        return "integer";
+    }
+    return typeof value;
+}
+function receivedValue(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (value === undefined) {
+        return "undefined";
+    }
+    return String(value);
+}
+function formatReceivedDiscriminator(value) {
+    if (typeof value === "string") {
+        return JSON.stringify(value);
+    }
+    return receivedValue(value);
+}

package/node_modules/toolcraft/node_modules/toolcraft-schema/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "toolcraft-schema",
+  "version": "0.0.893",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc",
+    "test": "cd ../.. && vitest run packages/toolcraft-schema/src",
+    "test:unit": "cd ../.. && vitest run packages/toolcraft-schema/src",
+    "lint": "cd ../.. && eslint packages/toolcraft-schema/src --ext ts && tsc -p packages/toolcraft-schema/tsconfig.json --noEmit"
+  },
+  "files": [
+    "LICENSE",
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18.18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/poe-platform/poe-code.git",
+    "directory": "packages/toolcraft-schema"
+  }
+}

package/node_modules/toolcraft/node_modules/xmlchars/LICENSE

@@ -0,0 +1,18 @@
+Copyright Louis-Dominique Dubeau and contributors to xmlchars
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.