@scallywag/validation 1.0.0 → 1.0.4

package/dist/wrappers.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Validation Wrappers
+ *
+ * High-level wrapper functions for common validation patterns.
+ * These provide ergonomic APIs for JSON parsing with schema validation
+ * and type-safe assertion helpers.
+ */
+import { z } from 'zod';
+import type { ValidationError } from './types';
+/**
+ * Error thrown when JSON parsing fails
+ */
+export declare class JsonParseError extends Error {
+    readonly code: "JSON_PARSE_ERROR";
+    readonly rawInput: string;
+    constructor(message: string, rawInput: string, cause?: Error);
+}
+/**
+ * Error thrown when schema validation fails
+ */
+export declare class SchemaValidationError extends Error {
+    readonly code: "SCHEMA_VALIDATION_ERROR";
+    readonly errors: ValidationError[];
+    readonly value: unknown;
+    constructor(message: string, errors: ValidationError[], value: unknown);
+    /**
+     * Get a formatted summary of validation errors
+     */
+    getErrorSummary(): string;
+}
+/**
+ * Parse a JSON string and validate it against a Zod schema.
+ *
+ * Combines JSON.parse() with Zod validation in a single operation,
+ * providing type-safe parsing with clear error types.
+ *
+ * @param json - The JSON string to parse
+ * @param schema - The Zod schema to validate against
+ * @returns The parsed and validated data with full type inference
+ * @throws JsonParseError if the JSON string is malformed
+ * @throws SchemaValidationError if the parsed data fails schema validation
+ *
+ * @example
+ * const UserSchema = z.object(\{
+ *   id: z.string().uuid(),
+ *   name: z.string().min(1),
+ *   email: z.string().email(),
+ * \});
+ *
+ * // Fully typed: user is \{ id: string; name: string; email: string \}
+ * const user = parseJsonWithSchema(jsonString, UserSchema);
+ *
+ * // Error handling - catch JsonParseError for invalid JSON
+ * // and SchemaValidationError for validation failures
+ */
+export declare function parseJsonWithSchema<T>(json: string, schema: z.ZodSchema<T>): T;
+/**
+ * Assert that a value conforms to a Zod schema, narrowing the type.
+ *
+ * This is a type assertion function that throws if validation fails,
+ * allowing TypeScript to narrow the type after the assertion.
+ *
+ * @param value - The value to validate
+ * @param schema - The Zod schema to validate against
+ * @throws SchemaValidationError if validation fails
+ *
+ * @example
+ * const ConfigSchema = z.object(\{ port: z.number(), host: z.string() \});
+ *
+ * function loadConfig(rawConfig: unknown): void \{
+ *   // After this line, TypeScript knows rawConfig is \{ port: number; host: string \}
+ *   assertSchema(rawConfig, ConfigSchema);
+ *   // Type-safe access to rawConfig.host and rawConfig.port
+ * \}
+ */
+export declare function assertSchema<T>(value: unknown, schema: z.ZodSchema<T>): asserts value is T;
+/**
+ * Type guard version of assertSchema that returns a boolean instead of throwing.
+ *
+ * Useful when you want to check if a value matches a schema without throwing,
+ * while still getting type narrowing in the true branch.
+ *
+ * @param value - The value to check
+ * @param schema - The Zod schema to validate against
+ * @returns True if the value matches the schema, false otherwise
+ *
+ * @example
+ * function handleMessage(msg: unknown): void \{
+ *   if (isSchema(msg, TextMessageSchema)) \{
+ *     // msg is typed as TextMessage here
+ *   \} else if (isSchema(msg, ImageMessageSchema)) \{
+ *     // msg is typed as ImageMessage here
+ *   \}
+ * \}
+ */
+export declare function isSchema<T>(value: unknown, schema: z.ZodSchema<T>): value is T;
+/**
+ * Parse JSON string safely, returning the parsed value or a default.
+ *
+ * Use this when you need to parse JSON before applying a Zod schema,
+ * or when the schema is determined dynamically.
+ *
+ * @param json - The JSON string to parse
+ * @param defaultValue - Value to return if parsing fails
+ * @returns The parsed value as unknown, or the default value
+ *
+ * @example
+ * ```typescript
+ * // Parse request body, defaulting to empty object on failure
+ * const body = safeParseJson(text, {});
+ *
+ * // Then validate with a schema
+ * const validated = MySchema.parse(body);
+ * ```
+ */
+export declare function safeParseJson(json: string, defaultValue?: unknown): unknown;
+//# sourceMappingURL=wrappers.d.ts.map

package/dist/wrappers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrappers.d.ts","sourceRoot":"","sources":["../wrappers.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C;;GAEG;AACH,qBAAa,cAAe,SAAQ,KAAK;IACvC,SAAgB,IAAI,EAAG,kBAAkB,CAAU;IACnD,SAAgB,QAAQ,EAAE,MAAM,CAAC;gBAErB,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK;CAgB7D;AAED;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,SAAgB,IAAI,EAAG,yBAAyB,CAAU;IAC1D,SAAgB,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1C,SAAgB,KAAK,EAAE,OAAO,CAAC;gBAEnB,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,EAAE,KAAK,EAAE,OAAO;IAUtE;;OAEG;IACI,eAAe,IAAI,MAAM;CAGjC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EACnC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GACrB,CAAC,CAuCH;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC5B,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GACrB,OAAO,CAAC,KAAK,IAAI,CAAC,CAsBpB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EACxB,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GACrB,KAAK,IAAI,CAAC,CAEZ;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,YAAY,GAAE,OAAc,GAC3B,OAAO,CAMT"}

package/dist/wrappers.js

@@ -0,0 +1,184 @@
+/**
+ * Validation Wrappers
+ *
+ * High-level wrapper functions for common validation patterns.
+ * These provide ergonomic APIs for JSON parsing with schema validation
+ * and type-safe assertion helpers.
+ */
+/**
+ * Error thrown when JSON parsing fails
+ */
+export class JsonParseError extends Error {
+    constructor(message, rawInput, cause) {
+        super(message);
+        this.code = 'JSON_PARSE_ERROR';
+        this.name = 'JsonParseError';
+        this.rawInput = rawInput;
+        if (cause !== undefined) {
+            Object.defineProperty(this, 'cause', {
+                value: cause,
+                writable: false,
+                enumerable: false,
+                configurable: false,
+            });
+        }
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+}
+/**
+ * Error thrown when schema validation fails
+ */
+export class SchemaValidationError extends Error {
+    constructor(message, errors, value) {
+        super(message);
+        this.code = 'SCHEMA_VALIDATION_ERROR';
+        this.name = 'SchemaValidationError';
+        this.errors = errors;
+        this.value = value;
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+    /**
+     * Get a formatted summary of validation errors
+     */
+    getErrorSummary() {
+        return this.errors.map((err) => `${err.field}: ${err.message}`).join('; ');
+    }
+}
+/**
+ * Parse a JSON string and validate it against a Zod schema.
+ *
+ * Combines JSON.parse() with Zod validation in a single operation,
+ * providing type-safe parsing with clear error types.
+ *
+ * @param json - The JSON string to parse
+ * @param schema - The Zod schema to validate against
+ * @returns The parsed and validated data with full type inference
+ * @throws JsonParseError if the JSON string is malformed
+ * @throws SchemaValidationError if the parsed data fails schema validation
+ *
+ * @example
+ * const UserSchema = z.object(\{
+ *   id: z.string().uuid(),
+ *   name: z.string().min(1),
+ *   email: z.string().email(),
+ * \});
+ *
+ * // Fully typed: user is \{ id: string; name: string; email: string \}
+ * const user = parseJsonWithSchema(jsonString, UserSchema);
+ *
+ * // Error handling - catch JsonParseError for invalid JSON
+ * // and SchemaValidationError for validation failures
+ */
+export function parseJsonWithSchema(json, schema) {
+    // Step 1: Parse JSON
+    let parsed;
+    try {
+        parsed = JSON.parse(json);
+    }
+    catch (error) {
+        const message = error instanceof SyntaxError
+            ? `Invalid JSON: ${error.message}`
+            : 'Invalid JSON: Unknown parsing error';
+        throw new JsonParseError(message, json, error instanceof Error ? error : undefined);
+    }
+    // Step 2: Validate against schema
+    const result = schema.safeParse(parsed);
+    if (result.success) {
+        return result.data;
+    }
+    // Convert ZodError to ValidationError array
+    const validationErrors = result.error.issues.map((issue) => ({
+        field: issue.path.join('.') || 'root',
+        message: issue.message,
+        code: issue.code,
+        value: 'received' in issue ? issue.received : undefined,
+    }));
+    throw new SchemaValidationError(`Schema validation failed: ${validationErrors.length} error(s)`, validationErrors, parsed);
+}
+/**
+ * Assert that a value conforms to a Zod schema, narrowing the type.
+ *
+ * This is a type assertion function that throws if validation fails,
+ * allowing TypeScript to narrow the type after the assertion.
+ *
+ * @param value - The value to validate
+ * @param schema - The Zod schema to validate against
+ * @throws SchemaValidationError if validation fails
+ *
+ * @example
+ * const ConfigSchema = z.object(\{ port: z.number(), host: z.string() \});
+ *
+ * function loadConfig(rawConfig: unknown): void \{
+ *   // After this line, TypeScript knows rawConfig is \{ port: number; host: string \}
+ *   assertSchema(rawConfig, ConfigSchema);
+ *   // Type-safe access to rawConfig.host and rawConfig.port
+ * \}
+ */
+export function assertSchema(value, schema) {
+    const result = schema.safeParse(value);
+    if (result.success) {
+        return;
+    }
+    // Convert ZodError to ValidationError array
+    const validationErrors = result.error.issues.map((issue) => ({
+        field: issue.path.join('.') || 'root',
+        message: issue.message,
+        code: issue.code,
+        value: 'received' in issue ? issue.received : undefined,
+    }));
+    throw new SchemaValidationError(`Assertion failed: value does not match schema`, validationErrors, value);
+}
+/**
+ * Type guard version of assertSchema that returns a boolean instead of throwing.
+ *
+ * Useful when you want to check if a value matches a schema without throwing,
+ * while still getting type narrowing in the true branch.
+ *
+ * @param value - The value to check
+ * @param schema - The Zod schema to validate against
+ * @returns True if the value matches the schema, false otherwise
+ *
+ * @example
+ * function handleMessage(msg: unknown): void \{
+ *   if (isSchema(msg, TextMessageSchema)) \{
+ *     // msg is typed as TextMessage here
+ *   \} else if (isSchema(msg, ImageMessageSchema)) \{
+ *     // msg is typed as ImageMessage here
+ *   \}
+ * \}
+ */
+export function isSchema(value, schema) {
+    return schema.safeParse(value).success;
+}
+/**
+ * Parse JSON string safely, returning the parsed value or a default.
+ *
+ * Use this when you need to parse JSON before applying a Zod schema,
+ * or when the schema is determined dynamically.
+ *
+ * @param json - The JSON string to parse
+ * @param defaultValue - Value to return if parsing fails
+ * @returns The parsed value as unknown, or the default value
+ *
+ * @example
+ * ```typescript
+ * // Parse request body, defaulting to empty object on failure
+ * const body = safeParseJson(text, {});
+ *
+ * // Then validate with a schema
+ * const validated = MySchema.parse(body);
+ * ```
+ */
+export function safeParseJson(json, defaultValue = null) {
+    try {
+        return JSON.parse(json);
+    }
+    catch (_a) {
+        return defaultValue;
+    }
+}
+//# sourceMappingURL=wrappers.js.map

package/dist/wrappers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrappers.js","sourceRoot":"","sources":["../wrappers.ts"],"names":[],"mappings":"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"}

package/dist/zod-schema-converter.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Zod Schema Converter
+ *
+ * Converts Zod schemas to JSON Schema using Zod 4's native toJSONSchema() method.
+ * This enables a single source of truth: define schemas in Zod, derive JSON Schema
+ * for MCP tools, OpenAPI docs, and discovery metadata automatically.
+ *
+ * @module kernel/validation/zod-schema-converter
+ */
+import type { ZodSchema } from 'zod';
+/**
+ * JSON Schema type - the result of toJSONSchema()
+ */
+export type JsonSchema = Record<string, unknown>;
+/**
+ * Converts a Zod schema to JSON Schema using Zod 4's native method.
+ *
+ * @param schema - The Zod schema to convert
+ * @returns JSON Schema representation of the Zod schema
+ * @throws Error if schema doesn't support toJSONSchema (non-Zod 4)
+ *
+ * @example
+ * ```typescript
+ * const userSchema = z.object({ name: z.string(), age: z.number() });
+ * const jsonSchema = zodToJsonSchema(userSchema);
+ * // { type: 'object', properties: { name: { type: 'string' }, age: { type: 'number' } }, required: ['name', 'age'] }
+ * ```
+ */
+export declare function zodToJsonSchema(schema: ZodSchema): JsonSchema;
+/**
+ * Safely converts a Zod schema to JSON Schema, returning undefined on failure.
+ * Useful when schema conversion is optional and shouldn't break the flow.
+ *
+ * @param schema - The Zod schema to convert (may be undefined)
+ * @returns JSON Schema representation or undefined
+ *
+ * @example
+ * ```typescript
+ * const schema = validation?.input;
+ * const jsonSchema = safeZodToJsonSchema(schema);
+ * // Returns undefined if schema is undefined or conversion fails
+ * ```
+ */
+export declare function safeZodToJsonSchema(schema: ZodSchema | undefined): JsonSchema | undefined;
+/**
+ * Schema extraction result for method input/output schemas.
+ */
+export interface MethodSchemas {
+    /** JSON Schema for method input parameters */
+    input?: JsonSchema | undefined;
+    /** JSON Schema for method return value */
+    output?: JsonSchema | undefined;
+}
+/**
+ * Extracts JSON Schema from Zod schemas for method input and output.
+ * Used by ConventionProcessor to embed schemas in discovery metadata.
+ *
+ * @param inputSchema - Zod schema for method input (optional)
+ * @param outputSchema - Zod schema for method output (optional)
+ * @returns Object with input/output JSON Schemas (undefined if not provided)
+ *
+ * @example
+ * ```typescript
+ * const CreateEventSchema = z.object({ title: z.string() });
+ * const EventResponseSchema = z.object({ event: z.object({ id: z.string() }) });
+ *
+ * const schemas = extractMethodSchemas(CreateEventSchema, EventResponseSchema);
+ * // { input: { type: 'object', ... }, output: { type: 'object', ... } }
+ * ```
+ */
+export declare function extractMethodSchemas(inputSchema?: ZodSchema, outputSchema?: ZodSchema): MethodSchemas;
+/**
+ * Checks if a value is a Zod schema with toJSONSchema support.
+ * Useful for runtime type checking in dynamic scenarios.
+ *
+ * @param value - Value to check
+ * @returns True if value is a Zod schema that supports JSON Schema conversion
+ */
+export declare function isZodSchemaWithJsonSupport(value: unknown): value is ZodSchema;
+//# sourceMappingURL=zod-schema-converter.d.ts.map

package/dist/zod-schema-converter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod-schema-converter.d.ts","sourceRoot":"","sources":["../zod-schema-converter.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,KAAK,CAAC;AAErC;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEjD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,GAAG,UAAU,CAc7D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,SAAS,GAAG,SAAS,GAC5B,UAAU,GAAG,SAAS,CAUxB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,8CAA8C;IAC9C,KAAK,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC;IAC/B,0CAA0C;IAC1C,MAAM,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC;CACjC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,oBAAoB,CAClC,WAAW,CAAC,EAAE,SAAS,EACvB,YAAY,CAAC,EAAE,SAAS,GACvB,aAAa,CAKf;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS,CAW7E"}

package/dist/zod-schema-converter.js

@@ -0,0 +1,97 @@
+/**
+ * Zod Schema Converter
+ *
+ * Converts Zod schemas to JSON Schema using Zod 4's native toJSONSchema() method.
+ * This enables a single source of truth: define schemas in Zod, derive JSON Schema
+ * for MCP tools, OpenAPI docs, and discovery metadata automatically.
+ *
+ * @module kernel/validation/zod-schema-converter
+ */
+/**
+ * Converts a Zod schema to JSON Schema using Zod 4's native method.
+ *
+ * @param schema - The Zod schema to convert
+ * @returns JSON Schema representation of the Zod schema
+ * @throws Error if schema doesn't support toJSONSchema (non-Zod 4)
+ *
+ * @example
+ * ```typescript
+ * const userSchema = z.object({ name: z.string(), age: z.number() });
+ * const jsonSchema = zodToJsonSchema(userSchema);
+ * // { type: 'object', properties: { name: { type: 'string' }, age: { type: 'number' } }, required: ['name', 'age'] }
+ * ```
+ */
+export function zodToJsonSchema(schema) {
+    // Zod 4 schemas have toJSONSchema() method directly
+    // Type assertion needed because ZodSchema base type doesn't expose it
+    const schemaWithMethod = schema;
+    if (typeof schemaWithMethod.toJSONSchema === 'function') {
+        return schemaWithMethod.toJSONSchema();
+    }
+    throw new Error('Schema does not support toJSONSchema(). Ensure Zod 4+ is installed and the schema is a valid Zod schema.');
+}
+/**
+ * Safely converts a Zod schema to JSON Schema, returning undefined on failure.
+ * Useful when schema conversion is optional and shouldn't break the flow.
+ *
+ * @param schema - The Zod schema to convert (may be undefined)
+ * @returns JSON Schema representation or undefined
+ *
+ * @example
+ * ```typescript
+ * const schema = validation?.input;
+ * const jsonSchema = safeZodToJsonSchema(schema);
+ * // Returns undefined if schema is undefined or conversion fails
+ * ```
+ */
+export function safeZodToJsonSchema(schema) {
+    if (!schema) {
+        return undefined;
+    }
+    try {
+        return zodToJsonSchema(schema);
+    }
+    catch (_a) {
+        return undefined;
+    }
+}
+/**
+ * Extracts JSON Schema from Zod schemas for method input and output.
+ * Used by ConventionProcessor to embed schemas in discovery metadata.
+ *
+ * @param inputSchema - Zod schema for method input (optional)
+ * @param outputSchema - Zod schema for method output (optional)
+ * @returns Object with input/output JSON Schemas (undefined if not provided)
+ *
+ * @example
+ * ```typescript
+ * const CreateEventSchema = z.object({ title: z.string() });
+ * const EventResponseSchema = z.object({ event: z.object({ id: z.string() }) });
+ *
+ * const schemas = extractMethodSchemas(CreateEventSchema, EventResponseSchema);
+ * // { input: { type: 'object', ... }, output: { type: 'object', ... } }
+ * ```
+ */
+export function extractMethodSchemas(inputSchema, outputSchema) {
+    return {
+        input: safeZodToJsonSchema(inputSchema),
+        output: safeZodToJsonSchema(outputSchema),
+    };
+}
+/**
+ * Checks if a value is a Zod schema with toJSONSchema support.
+ * Useful for runtime type checking in dynamic scenarios.
+ *
+ * @param value - Value to check
+ * @returns True if value is a Zod schema that supports JSON Schema conversion
+ */
+export function isZodSchemaWithJsonSupport(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const maybeSchema = value;
+    return (typeof maybeSchema['toJSONSchema'] === 'function' &&
+        typeof maybeSchema['parse'] === 'function' &&
+        typeof maybeSchema['safeParse'] === 'function');
+}
+//# sourceMappingURL=zod-schema-converter.js.map

package/dist/zod-schema-converter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod-schema-converter.js","sourceRoot":"","sources":["../zod-schema-converter.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AASH;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,eAAe,CAAC,MAAiB;IAC/C,oDAAoD;IACpD,sEAAsE;IACtE,MAAM,gBAAgB,GAAG,MAExB,CAAC;IAEF,IAAI,OAAO,gBAAgB,CAAC,YAAY,KAAK,UAAU,EAAE,CAAC;QACxD,OAAO,gBAAgB,CAAC,YAAY,EAAE,CAAC;IACzC,CAAC;IAED,MAAM,IAAI,KAAK,CACb,0GAA0G,CAC3G,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,mBAAmB,CACjC,MAA6B;IAE7B,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,IAAI,CAAC;QACH,OAAO,eAAe,CAAC,MAAM,CAAC,CAAC;IACjC,CAAC;IAAC,WAAM,CAAC;QACP,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC;AAYD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,oBAAoB,CAClC,WAAuB,EACvB,YAAwB;IAExB,OAAO;QACL,KAAK,EAAE,mBAAmB,CAAC,WAAW,CAAC;QACvC,MAAM,EAAE,mBAAmB,CAAC,YAAY,CAAC;KAC1C,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,0BAA0B,CAAC,KAAc;IACvD,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QAChD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,WAAW,GAAG,KAAgC,CAAC;IACrD,OAAO,CACL,OAAO,WAAW,CAAC,cAAc,CAAC,KAAK,UAAU;QACjD,OAAO,WAAW,CAAC,OAAO,CAAC,KAAK,UAAU;QAC1C,OAAO,WAAW,CAAC,WAAW,CAAC,KAAK,UAAU,CAC/C,CAAC;AACJ,CAAC"}

package/package.json

@@ -1 +1,40 @@
-{"name":"@scallywag/validation","version":"1.0.0","main":"index.js","publishConfig":{"access":"restricted"}}
+{
+  "name": "@scallywag/validation",
+  "version": "1.0.4",
+  "description": "ScallywagOS validation - Zod schemas, sanitization, XSS/SQL injection prevention",
+  "main": "./index.ts",
+  "types": "./index.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "restricted",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+      ".": {
+        "types": "./dist/index.d.ts",
+        "import": "./dist/index.js"
+      },
+      "./*": {
+        "types": "./dist/*.d.ts",
+        "import": "./dist/*.js"
+      }
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/We-Are-Scallywag/scallywagOS.git",
+    "directory": "packages/kernel/validation"
+  },
+  "scripts": {
+    "build": "tsc --build tsconfig.build.json",
+    "prepublishOnly": "pnpm run build",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@scallywag/gateway": "workspace:*",
+    "@scallywag/security": "workspace:*"
+  }
+}

package/index.js

@@ -1 +0,0 @@
-// test