@utilarium/overcontext 0.0.4-dev.0

package/dist/namespace/resolver.js

@@ -0,0 +1,85 @@
+const createNamespaceResolver = (options)=>{
+    const { provider, defaultNamespace = '_default' } = options;
+    const configuredNamespaces = new Map();
+    // Load initial configurations
+    if (options.namespaces) {
+        for (const ns of options.namespaces){
+            configuredNamespaces.set(ns.id, ns);
+        }
+    }
+    return {
+        async resolve (requested) {
+            let namespaceIds;
+            if (!requested) {
+                namespaceIds = [
+                    defaultNamespace
+                ];
+            } else if (typeof requested === 'string') {
+                namespaceIds = [
+                    requested
+                ];
+            } else {
+                namespaceIds = requested;
+            }
+            const references = [];
+            const readable = [];
+            let primary;
+            for(let i = 0; i < namespaceIds.length; i++){
+                const nsId = namespaceIds[i];
+                const config = configuredNamespaces.get(nsId);
+                // Include all requested namespaces, even if they don't exist yet
+                const ref = {
+                    namespace: nsId,
+                    priority: namespaceIds.length - i,
+                    searchable: (config === null || config === void 0 ? void 0 : config.active) !== false,
+                    writable: i === 0
+                };
+                references.push(ref);
+                readable.push(nsId);
+                if (!primary) {
+                    primary = nsId;
+                }
+            }
+            if (!primary) {
+                primary = defaultNamespace;
+                readable.push(defaultNamespace);
+            }
+            return {
+                primary,
+                readable,
+                references
+            };
+        },
+        async listAll () {
+            const discovered = await provider.listNamespaces();
+            const all = new Map();
+            // Add configured namespaces
+            for (const [id, config] of configuredNamespaces){
+                all.set(id, config);
+            }
+            // Add discovered namespaces
+            for (const nsId of discovered){
+                if (!all.has(nsId)) {
+                    all.set(nsId, {
+                        id: nsId,
+                        name: nsId,
+                        active: true
+                    });
+                }
+            }
+            return Array.from(all.values());
+        },
+        register (config) {
+            configuredNamespaces.set(config.id, config);
+        },
+        getPrimary () {
+            return defaultNamespace;
+        },
+        async exists (namespace) {
+            return configuredNamespaces.has(namespace) || await provider.namespaceExists(namespace);
+        }
+    };
+};
+
+export { createNamespaceResolver };
+//# sourceMappingURL=resolver.js.map

package/dist/namespace/resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver.js","sources":["../../src/namespace/resolver.ts"],"sourcesContent":["import { StorageProvider } from '../storage/interface';\nimport { NamespaceConfig, NamespaceReference, NamespaceResolution } from './types';\n\nexport interface NamespaceResolverOptions {\n    /** Storage provider to query for namespaces */\n    provider: StorageProvider;\n\n    /** Default namespace when none specified */\n    defaultNamespace?: string;\n\n    /** Pre-configured namespaces */\n    namespaces?: NamespaceConfig[];\n}\n\nexport interface NamespaceResolver {\n    /**\n     * Resolve which namespaces to use for an operation.\n     */\n    resolve(requested?: string | string[]): Promise<NamespaceResolution>;\n\n    /**\n     * Get all available namespaces.\n     */\n    listAll(): Promise<NamespaceConfig[]>;\n\n    /**\n     * Register a new namespace configuration.\n     */\n    register(config: NamespaceConfig): void;\n\n    /**\n     * Get the primary (writable) namespace.\n     */\n    getPrimary(): string;\n\n    /**\n     * Check if a namespace exists.\n     */\n    exists(namespace: string): Promise<boolean>;\n}\n\nexport const createNamespaceResolver = (\n    options: NamespaceResolverOptions\n): NamespaceResolver => {\n    const { provider, defaultNamespace = '_default' } = options;\n    const configuredNamespaces = new Map<string, NamespaceConfig>();\n\n    // Load initial configurations\n    if (options.namespaces) {\n        for (const ns of options.namespaces) {\n            configuredNamespaces.set(ns.id, ns);\n        }\n    }\n\n    return {\n        async resolve(requested?: string | string[]): Promise<NamespaceResolution> {\n            let namespaceIds: string[];\n\n            if (!requested) {\n                namespaceIds = [defaultNamespace];\n            } else if (typeof requested === 'string') {\n                namespaceIds = [requested];\n            } else {\n                namespaceIds = requested;\n            }\n\n            const references: NamespaceReference[] = [];\n            const readable: string[] = [];\n            let primary: string | undefined;\n\n            for (let i = 0; i < namespaceIds.length; i++) {\n                const nsId = namespaceIds[i];\n                const config = configuredNamespaces.get(nsId);\n\n                // Include all requested namespaces, even if they don't exist yet\n                const ref: NamespaceReference = {\n                    namespace: nsId,\n                    priority: namespaceIds.length - i,  // Earlier = higher priority\n                    searchable: config?.active !== false,\n                    writable: i === 0,  // Only first is writable\n                };\n\n                references.push(ref);\n                readable.push(nsId);\n\n                if (!primary) {\n                    primary = nsId;\n                }\n            }\n\n            if (!primary) {\n                primary = defaultNamespace;\n                readable.push(defaultNamespace);\n            }\n\n            return { primary, readable, references };\n        },\n\n        async listAll(): Promise<NamespaceConfig[]> {\n            const discovered = await provider.listNamespaces();\n            const all = new Map<string, NamespaceConfig>();\n\n            // Add configured namespaces\n            for (const [id, config] of configuredNamespaces) {\n                all.set(id, config);\n            }\n\n            // Add discovered namespaces\n            for (const nsId of discovered) {\n                if (!all.has(nsId)) {\n                    all.set(nsId, { id: nsId, name: nsId, active: true });\n                }\n            }\n\n            return Array.from(all.values());\n        },\n\n        register(config: NamespaceConfig): void {\n            configuredNamespaces.set(config.id, config);\n        },\n\n        getPrimary(): string {\n            return defaultNamespace;\n        },\n\n        async exists(namespace: string): Promise<boolean> {\n            return configuredNamespaces.has(namespace) ||\n                   await provider.namespaceExists(namespace);\n        },\n    };\n};\n"],"names":["createNamespaceResolver","options","provider","defaultNamespace","configuredNamespaces","Map","namespaces","ns","set","id","resolve","requested","namespaceIds","references","readable","primary","i","length","nsId","config","get","ref","namespace","priority","searchable","active","writable","push","listAll","discovered","listNamespaces","all","has","name","Array","from","values","register","getPrimary","exists","namespaceExists"],"mappings":"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"}

package/dist/namespace/types.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Configuration for a namespace.
+ */
+export interface NamespaceConfig {
+    /** Unique identifier for the namespace */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** Description of what this namespace contains */
+    description?: string;
+    /** Parent namespace (for hierarchy) */
+    parent?: string;
+    /** Tools/projects that use this namespace */
+    consumers?: string[];
+    /** Whether this namespace is active */
+    active?: boolean;
+}
+/**
+ * Reference to a namespace with resolution metadata.
+ */
+export interface NamespaceReference {
+    /** The namespace ID */
+    namespace: string;
+    /** Priority for merging (higher = preferred) */
+    priority: number;
+    /** Whether to include in searches */
+    searchable: boolean;
+    /** Whether writes go to this namespace */
+    writable: boolean;
+}
+/**
+ * Result of namespace resolution.
+ */
+export interface NamespaceResolution {
+    /** Primary namespace for writes */
+    primary: string;
+    /** All namespaces to read from (in priority order) */
+    readable: string[];
+    /** Resolved namespace references */
+    references: NamespaceReference[];
+}

package/dist/overcontext.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Overcontext - Schema-driven framework for context management
+ *
+ * This is a placeholder entry point that will be expanded in later steps.
+ */
+export * from './schema';
+export * from './storage';

package/dist/schema/base.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+/**
+ * Metadata that overcontext manages automatically.
+ * Consumers don't need to define these.
+ */
+export declare const EntityMetadataSchema: z.ZodObject<{
+    createdAt: z.ZodOptional<z.ZodDate>;
+    updatedAt: z.ZodOptional<z.ZodDate>;
+    createdBy: z.ZodOptional<z.ZodString>;
+    namespace: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type EntityMetadata = z.infer<typeof EntityMetadataSchema>;
+/**
+ * The minimal contract every entity must satisfy.
+ * Consuming libraries extend this with their own fields.
+ */
+export declare const BaseEntitySchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodString;
+    notes: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodDate>;
+    updatedAt: z.ZodOptional<z.ZodDate>;
+    createdBy: z.ZodOptional<z.ZodString>;
+    namespace: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type BaseEntity = z.infer<typeof BaseEntitySchema>;

package/dist/schema/base.js

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+
+/**
+ * Metadata that overcontext manages automatically.
+ * Consumers don't need to define these.
+ */ const EntityMetadataSchema = z.object({
+    createdAt: z.date().optional(),
+    updatedAt: z.date().optional(),
+    createdBy: z.string().optional(),
+    namespace: z.string().optional(),
+    source: z.string().optional()
+});
+/**
+ * The minimal contract every entity must satisfy.
+ * Consuming libraries extend this with their own fields.
+ */ const BaseEntitySchema = z.object({
+    /** Unique identifier within the entity type (used as filename) */ id: z.string().min(1),
+    /** Human-readable name (used for display and search) */ name: z.string().min(1),
+    /** Entity type discriminator (must be a string literal in extensions) */ type: z.string().min(1),
+    /** Optional notes - common enough to include in base */ notes: z.string().optional()
+}).merge(EntityMetadataSchema);
+
+export { BaseEntitySchema, EntityMetadataSchema };
+//# sourceMappingURL=base.js.map

package/dist/schema/base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.js","sources":["../../src/schema/base.ts"],"sourcesContent":["import { z } from 'zod';\n\n/**\n * Metadata that overcontext manages automatically.\n * Consumers don't need to define these.\n */\nexport const EntityMetadataSchema = z.object({\n    createdAt: z.date().optional(),\n    updatedAt: z.date().optional(),\n    createdBy: z.string().optional(),     // Tool that created this entity\n    namespace: z.string().optional(),      // Which namespace this came from\n    source: z.string().optional(),         // File path or storage key\n});\n\nexport type EntityMetadata = z.infer<typeof EntityMetadataSchema>;\n\n/**\n * The minimal contract every entity must satisfy.\n * Consuming libraries extend this with their own fields.\n */\nexport const BaseEntitySchema = z.object({\n    /** Unique identifier within the entity type (used as filename) */\n    id: z.string().min(1),\n\n    /** Human-readable name (used for display and search) */\n    name: z.string().min(1),\n\n    /** Entity type discriminator (must be a string literal in extensions) */\n    type: z.string().min(1),\n\n    /** Optional notes - common enough to include in base */\n    notes: z.string().optional(),\n}).merge(EntityMetadataSchema);\n\nexport type BaseEntity = z.infer<typeof BaseEntitySchema>;\n"],"names":["EntityMetadataSchema","z","object","createdAt","date","optional","updatedAt","createdBy","string","namespace","source","BaseEntitySchema","id","min","name","type","notes","merge"],"mappings":";;AAEA;;;AAGC,IACM,MAAMA,oBAAAA,GAAuBC,CAAAA,CAAEC,MAAM,CAAC;IACzCC,SAAAA,EAAWF,CAAAA,CAAEG,IAAI,EAAA,CAAGC,QAAQ,EAAA;IAC5BC,SAAAA,EAAWL,CAAAA,CAAEG,IAAI,EAAA,CAAGC,QAAQ,EAAA;IAC5BE,SAAAA,EAAWN,CAAAA,CAAEO,MAAM,EAAA,CAAGH,QAAQ,EAAA;IAC9BI,SAAAA,EAAWR,CAAAA,CAAEO,MAAM,EAAA,CAAGH,QAAQ,EAAA;IAC9BK,MAAAA,EAAQT,CAAAA,CAAEO,MAAM,EAAA,CAAGH,QAAQ;AAC/B,CAAA;AAIA;;;AAGC,IACM,MAAMM,gBAAAA,GAAmBV,CAAAA,CAAEC,MAAM,CAAC;AACrC,uEACAU,EAAAA,EAAIX,CAAAA,CAAEO,MAAM,EAAA,CAAGK,GAAG,CAAC,CAAA,CAAA;AAEnB,6DACAC,IAAAA,EAAMb,CAAAA,CAAEO,MAAM,EAAA,CAAGK,GAAG,CAAC,CAAA,CAAA;AAErB,8EACAE,IAAAA,EAAMd,CAAAA,CAAEO,MAAM,EAAA,CAAGK,GAAG,CAAC,CAAA,CAAA;AAErB,6DACAG,KAAAA,EAAOf,CAAAA,CAAEO,MAAM,GAAGH,QAAQ;AAC9B,CAAA,CAAA,CAAGY,KAAK,CAACjB,oBAAAA;;;;"}

package/dist/schema/builder.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { BaseEntity } from './base';
+/**
+ * Type-safe builder for schema maps.
+ * Ensures type inference works correctly.
+ */
+export type SchemaMapBuilder<T extends Record<string, z.ZodType<BaseEntity>>> = {
+    schemas: T;
+    types: {
+        [K in keyof T]: z.infer<T[K]>;
+    };
+};
+/**
+ * Create a schema map with proper type inference.
+ *
+ * @example
+ * const { schemas, types } = defineSchemas({
+ *   person: PersonSchema,
+ *   project: ProjectSchema,
+ * });
+ *
+ * type Person = typeof types.person;  // Inferred from PersonSchema
+ */
+export declare const defineSchemas: <T extends Record<string, z.ZodType<BaseEntity>>>(schemas: T) => SchemaMapBuilder<T>;
+/**
+ * Helper to check if a schema extends BaseEntity properly.
+ */
+export declare const isValidEntitySchema: (schema: z.ZodType<unknown>) => boolean;

package/dist/schema/builder.js

@@ -0,0 +1,39 @@
+/**
+ * Create a schema map with proper type inference.
+ * 
+ * @example
+ * const { schemas, types } = defineSchemas({
+ *   person: PersonSchema,
+ *   project: ProjectSchema,
+ * });
+ * 
+ * type Person = typeof types.person;  // Inferred from PersonSchema
+ */ const defineSchemas = (schemas)=>{
+    return {
+        schemas,
+        types: {}
+    };
+};
+/**
+ * Helper to check if a schema extends BaseEntity properly.
+ */ const isValidEntitySchema = (schema)=>{
+    try {
+        // BaseEntitySchema allows extra fields, so we just need id, name, type
+        const result = schema.safeParse({
+            id: 'test',
+            name: 'Test',
+            type: 'test'
+        });
+        // If it fails, it might be because type is a literal
+        // Try without type and check if it has the base structure
+        if (!result.success) {
+            return false;
+        }
+        return true;
+    } catch  {
+        return false;
+    }
+};
+
+export { defineSchemas, isValidEntitySchema };
+//# sourceMappingURL=builder.js.map

package/dist/schema/builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.js","sources":["../../src/schema/builder.ts"],"sourcesContent":["import { z } from 'zod';\nimport { BaseEntity } from './base';\n\n/**\n * Type-safe builder for schema maps.\n * Ensures type inference works correctly.\n */\nexport type SchemaMapBuilder<T extends Record<string, z.ZodType<BaseEntity>>> = {\n    schemas: T;\n    types: { [K in keyof T]: z.infer<T[K]> };\n};\n\n/**\n * Create a schema map with proper type inference.\n * \n * @example\n * const { schemas, types } = defineSchemas({\n *   person: PersonSchema,\n *   project: ProjectSchema,\n * });\n * \n * type Person = typeof types.person;  // Inferred from PersonSchema\n */\nexport const defineSchemas = <T extends Record<string, z.ZodType<BaseEntity>>>(\n    schemas: T\n): SchemaMapBuilder<T> => {\n    return {\n        schemas,\n        types: {} as { [K in keyof T]: z.infer<T[K]> },\n    };\n};\n\n/**\n * Helper to check if a schema extends BaseEntity properly.\n */\nexport const isValidEntitySchema = (schema: z.ZodType<unknown>): boolean => {\n    try {\n        // BaseEntitySchema allows extra fields, so we just need id, name, type\n        const result = schema.safeParse({\n            id: 'test',\n            name: 'Test',\n            type: 'test',\n        });\n        // If it fails, it might be because type is a literal\n        // Try without type and check if it has the base structure\n        if (!result.success) {\n            return false;\n        }\n        return true;\n    } catch {\n        return false;\n    }\n};\n"],"names":["defineSchemas","schemas","types","isValidEntitySchema","schema","result","safeParse","id","name","type","success"],"mappings":"AAYA;;;;;;;;;;IAWO,MAAMA,aAAAA,GAAgB,CACzBC,OAAAA,GAAAA;IAEA,OAAO;AACHA,QAAAA,OAAAA;AACAC,QAAAA,KAAAA,EAAO;AACX,KAAA;AACJ;AAEA;;IAGO,MAAMC,mBAAAA,GAAsB,CAACC,MAAAA,GAAAA;IAChC,IAAI;;QAEA,MAAMC,MAAAA,GAASD,MAAAA,CAAOE,SAAS,CAAC;YAC5BC,EAAAA,EAAI,MAAA;YACJC,IAAAA,EAAM,MAAA;YACNC,IAAAA,EAAM;AACV,SAAA,CAAA;;;QAGA,IAAI,CAACJ,MAAAA,CAAOK,OAAO,EAAE;YACjB,OAAO,KAAA;AACX,QAAA;QACA,OAAO,IAAA;AACX,IAAA,CAAA,CAAE,OAAM;QACJ,OAAO,KAAA;AACX,IAAA;AACJ;;;;"}

package/dist/schema/index.d.ts

@@ -0,0 +1,5 @@
+export * from './base';
+export * from './inference';
+export * from './validation';
+export * from './registry';
+export * from './builder';

package/dist/schema/inference.d.ts

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import { BaseEntity } from './base';
+/**
+ * A valid entity schema must extend BaseEntitySchema.
+ * The type field should be a literal (e.g., z.literal('person')).
+ */
+export type EntitySchema<T extends BaseEntity = BaseEntity> = z.ZodType<T> & {
+    _input: T;
+    _output: T;
+};
+/**
+ * Helper to create a properly typed entity schema.
+ * Ensures the schema extends BaseEntitySchema.
+ */
+export declare const createEntitySchema: <TType extends string, TExtension extends z.ZodRawShape>(typeName: TType, extension: TExtension) => z.ZodObject<(("createdAt" | "updatedAt" | "createdBy" | "namespace" | "source" | "type" | "id" | "name" | "notes") & ("type" | keyof TExtension) extends never ? {
+    id: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodString;
+    notes: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodDate>;
+    updatedAt: z.ZodOptional<z.ZodDate>;
+    createdBy: z.ZodOptional<z.ZodString>;
+    namespace: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodString>;
+} & {
+    type: z.ZodLiteral<TType>;
+} & TExtension : ({
+    id: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodString;
+    notes: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodDate>;
+    updatedAt: z.ZodOptional<z.ZodDate>;
+    createdBy: z.ZodOptional<z.ZodString>;
+    namespace: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodString>;
+} extends infer T_1 extends z.core.util.SomeObject ? { [K in keyof T_1 as K extends "type" | keyof TExtension ? never : K]: T_1[K]; } : never) & ({
+    type: z.ZodLiteral<TType>;
+} & TExtension extends infer T_2 extends z.core.util.SomeObject ? { [K_1 in keyof T_2]: T_2[K_1]; } : never)) extends infer T ? { [k in keyof T]: T[k]; } : never, z.core.$strip>;
+/**
+ * Extract the type literal from an entity schema.
+ */
+export type EntityTypeFromSchema<T extends z.ZodType<BaseEntity>> = T extends z.ZodType<infer U> ? (U extends {
+    type: infer TType;
+} ? TType : never) : never;
+/**
+ * Extract the full entity type from a schema.
+ */
+export type InferEntity<T extends z.ZodType<BaseEntity>> = z.infer<T>;

package/dist/schema/inference.js

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { BaseEntitySchema } from './base.js';
+
+/**
+ * Helper to create a properly typed entity schema.
+ * Ensures the schema extends BaseEntitySchema.
+ */ const createEntitySchema = (typeName, extension)=>{
+    return BaseEntitySchema.extend({
+        type: z.literal(typeName),
+        ...extension
+    });
+};
+
+export { createEntitySchema };
+//# sourceMappingURL=inference.js.map

package/dist/schema/inference.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inference.js","sources":["../../src/schema/inference.ts"],"sourcesContent":["import { z } from 'zod';\nimport { BaseEntitySchema, BaseEntity } from './base';\n\n/**\n * A valid entity schema must extend BaseEntitySchema.\n * The type field should be a literal (e.g., z.literal('person')).\n */\nexport type EntitySchema<T extends BaseEntity = BaseEntity> = z.ZodType<T> & {\n    _input: T;\n    _output: T;\n};\n\n/**\n * Helper to create a properly typed entity schema.\n * Ensures the schema extends BaseEntitySchema.\n */\nexport const createEntitySchema = <\n    TType extends string,\n    TExtension extends z.ZodRawShape\n>(\n        typeName: TType,\n        extension: TExtension\n    ) => {\n    return BaseEntitySchema.extend({\n        type: z.literal(typeName),\n        ...extension,\n    });\n};\n\n/**\n * Extract the type literal from an entity schema.\n */\nexport type EntityTypeFromSchema<T extends z.ZodType<BaseEntity>> =\n    T extends z.ZodType<infer U> ? (U extends { type: infer TType } ? TType : never) : never;\n\n/**\n * Extract the full entity type from a schema.\n */\nexport type InferEntity<T extends z.ZodType<BaseEntity>> = z.infer<T>;\n"],"names":["createEntitySchema","typeName","extension","BaseEntitySchema","extend","type","z","literal"],"mappings":";;;AAYA;;;AAGC,IACM,MAAMA,kBAAAA,GAAqB,CAI1BC,QAAAA,EACAC,SAAAA,GAAAA;IAEJ,OAAOC,gBAAAA,CAAiBC,MAAM,CAAC;QAC3BC,IAAAA,EAAMC,CAAAA,CAAEC,OAAO,CAACN,QAAAA,CAAAA;AAChB,QAAA,GAAGC;AACP,KAAA,CAAA;AACJ;;;;"}

package/dist/schema/registry.d.ts

@@ -0,0 +1,74 @@
+import { z } from 'zod';
+import { BaseEntity } from './base';
+import { ValidationResult } from './validation';
+/**
+ * A map of entity type names to their Zod schemas.
+ */
+export type SchemaMap = Record<string, z.ZodType<BaseEntity>>;
+/**
+ * Options for schema registration.
+ */
+export interface SchemaRegistrationOptions {
+    /** The type name (should match the schema's type literal) */
+    type: string;
+    /** The Zod schema for this entity type */
+    schema: z.ZodType<BaseEntity>;
+    /** Plural name for directory (e.g., 'people' for 'person') */
+    pluralName?: string;
+    /** Additional validation beyond schema */
+    customValidator?: (entity: BaseEntity) => ValidationResult<BaseEntity>;
+}
+/**
+ * Registered schema with metadata.
+ */
+export interface RegisteredSchema {
+    type: string;
+    schema: z.ZodType<BaseEntity>;
+    pluralName: string;
+    customValidator?: (entity: BaseEntity) => ValidationResult<BaseEntity>;
+}
+/**
+ * Schema registry for managing entity schemas.
+ */
+export interface SchemaRegistry {
+    /**
+     * Register a schema for an entity type.
+     */
+    register(options: SchemaRegistrationOptions): void;
+    /**
+     * Register multiple schemas at once.
+     */
+    registerAll(schemas: SchemaMap): void;
+    /**
+     * Get the schema for a type.
+     */
+    get(type: string): RegisteredSchema | undefined;
+    /**
+     * Check if a type is registered.
+     */
+    has(type: string): boolean;
+    /**
+     * Get all registered type names.
+     */
+    types(): string[];
+    /**
+     * Get the directory name for a type.
+     */
+    getDirectoryName(type: string): string | undefined;
+    /**
+     * Get the type from a directory name.
+     */
+    getTypeFromDirectory(directory: string): string | undefined;
+    /**
+     * Validate an entity against its registered schema.
+     */
+    validate<T extends BaseEntity>(entity: T): ValidationResult<T>;
+    /**
+     * Validate data as a specific type.
+     */
+    validateAs<T extends BaseEntity>(type: string, data: unknown): ValidationResult<T>;
+}
+/**
+ * Create a new schema registry.
+ */
+export declare const createSchemaRegistry: () => SchemaRegistry;

package/dist/schema/registry.js

@@ -0,0 +1,117 @@
+import { validateEntity } from './validation.js';
+
+/**
+ * Default plural name derivation.
+ */ const derivePluralName = (type)=>{
+    // Simple pluralization rules
+    if (type.endsWith('y')) {
+        return type.slice(0, -1) + 'ies';
+    }
+    if (type.endsWith('s') || type.endsWith('x') || type.endsWith('ch') || type.endsWith('sh')) {
+        return type + 'es';
+    }
+    return type + 's';
+};
+/**
+ * Create a new schema registry.
+ */ const createSchemaRegistry = ()=>{
+    const schemas = new Map();
+    const directoryToType = new Map();
+    const register = (options)=>{
+        const { type, schema, pluralName, customValidator } = options;
+        const plural = pluralName || derivePluralName(type);
+        const registered = {
+            type,
+            schema,
+            pluralName: plural,
+            customValidator
+        };
+        schemas.set(type, registered);
+        directoryToType.set(plural, type);
+    };
+    const registerAll = (schemaMap)=>{
+        for (const [type, schema] of Object.entries(schemaMap)){
+            register({
+                type,
+                schema
+            });
+        }
+    };
+    const get = (type)=>{
+        return schemas.get(type);
+    };
+    const has = (type)=>{
+        return schemas.has(type);
+    };
+    const types = ()=>{
+        return Array.from(schemas.keys());
+    };
+    const getDirectoryName = (type)=>{
+        var _schemas_get;
+        return (_schemas_get = schemas.get(type)) === null || _schemas_get === void 0 ? void 0 : _schemas_get.pluralName;
+    };
+    const getTypeFromDirectory = (directory)=>{
+        return directoryToType.get(directory);
+    };
+    const validate = (entity)=>{
+        const registered = schemas.get(entity.type);
+        if (!registered) {
+            return {
+                success: false,
+                errors: [
+                    {
+                        path: 'type',
+                        message: `Unknown entity type: ${entity.type}`
+                    }
+                ]
+            };
+        }
+        // Schema validation
+        const schemaResult = validateEntity(registered.schema, entity);
+        if (!schemaResult.success) {
+            return schemaResult;
+        }
+        // Custom validation
+        if (registered.customValidator) {
+            return registered.customValidator(entity);
+        }
+        return {
+            success: true,
+            data: entity
+        };
+    };
+    const validateAs = (type, data)=>{
+        const registered = schemas.get(type);
+        if (!registered) {
+            return {
+                success: false,
+                errors: [
+                    {
+                        path: 'type',
+                        message: `Unknown entity type: ${type}`
+                    }
+                ]
+            };
+        }
+        // Add type to data if missing (for convenience when loading from files)
+        const withType = typeof data === 'object' && data !== null ? {
+            ...data,
+            type
+        } : data;
+        return validateEntity(registered.schema, withType);
+    };
+    return {
+        register,
+        registerAll,
+        get,
+        has,
+        types,
+        getDirectoryName,
+        getTypeFromDirectory,
+        validate,
+        validateAs
+    };
+};
+
+export { createSchemaRegistry };
+//# sourceMappingURL=registry.js.map

package/dist/schema/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sources":["../../src/schema/registry.ts"],"sourcesContent":["import { z } from 'zod';\nimport { BaseEntity } from './base';\nimport { validateEntity, ValidationResult } from './validation';\n\n/**\n * A map of entity type names to their Zod schemas.\n */\nexport type SchemaMap = Record<string, z.ZodType<BaseEntity>>;\n\n/**\n * Options for schema registration.\n */\nexport interface SchemaRegistrationOptions {\n    /** The type name (should match the schema's type literal) */\n    type: string;\n\n    /** The Zod schema for this entity type */\n    schema: z.ZodType<BaseEntity>;\n\n    /** Plural name for directory (e.g., 'people' for 'person') */\n    pluralName?: string;\n\n    /** Additional validation beyond schema */\n    customValidator?: (entity: BaseEntity) => ValidationResult<BaseEntity>;\n}\n\n/**\n * Registered schema with metadata.\n */\nexport interface RegisteredSchema {\n    type: string;\n    schema: z.ZodType<BaseEntity>;\n    pluralName: string;\n    customValidator?: (entity: BaseEntity) => ValidationResult<BaseEntity>;\n}\n\n/**\n * Schema registry for managing entity schemas.\n */\nexport interface SchemaRegistry {\n    /**\n     * Register a schema for an entity type.\n     */\n    register(options: SchemaRegistrationOptions): void;\n\n    /**\n     * Register multiple schemas at once.\n     */\n    registerAll(schemas: SchemaMap): void;\n\n    /**\n     * Get the schema for a type.\n     */\n    get(type: string): RegisteredSchema | undefined;\n\n    /**\n     * Check if a type is registered.\n     */\n    has(type: string): boolean;\n\n    /**\n     * Get all registered type names.\n     */\n    types(): string[];\n\n    /**\n     * Get the directory name for a type.\n     */\n    getDirectoryName(type: string): string | undefined;\n\n    /**\n     * Get the type from a directory name.\n     */\n    getTypeFromDirectory(directory: string): string | undefined;\n\n    /**\n     * Validate an entity against its registered schema.\n     */\n    validate<T extends BaseEntity>(entity: T): ValidationResult<T>;\n\n    /**\n     * Validate data as a specific type.\n     */\n    validateAs<T extends BaseEntity>(type: string, data: unknown): ValidationResult<T>;\n}\n\n/**\n * Default plural name derivation.\n */\nconst derivePluralName = (type: string): string => {\n    // Simple pluralization rules\n    if (type.endsWith('y')) {\n        return type.slice(0, -1) + 'ies';\n    }\n    if (type.endsWith('s') || type.endsWith('x') || type.endsWith('ch') || type.endsWith('sh')) {\n        return type + 'es';\n    }\n    return type + 's';\n};\n\n/**\n * Create a new schema registry.\n */\nexport const createSchemaRegistry = (): SchemaRegistry => {\n    const schemas = new Map<string, RegisteredSchema>();\n    const directoryToType = new Map<string, string>();\n\n    const register = (options: SchemaRegistrationOptions): void => {\n        const { type, schema, pluralName, customValidator } = options;\n\n        const plural = pluralName || derivePluralName(type);\n\n        const registered: RegisteredSchema = {\n            type,\n            schema,\n            pluralName: plural,\n            customValidator,\n        };\n\n        schemas.set(type, registered);\n        directoryToType.set(plural, type);\n    };\n\n    const registerAll = (schemaMap: SchemaMap): void => {\n        for (const [type, schema] of Object.entries(schemaMap)) {\n            register({ type, schema });\n        }\n    };\n\n    const get = (type: string): RegisteredSchema | undefined => {\n        return schemas.get(type);\n    };\n\n    const has = (type: string): boolean => {\n        return schemas.has(type);\n    };\n\n    const types = (): string[] => {\n        return Array.from(schemas.keys());\n    };\n\n    const getDirectoryName = (type: string): string | undefined => {\n        return schemas.get(type)?.pluralName;\n    };\n\n    const getTypeFromDirectory = (directory: string): string | undefined => {\n        return directoryToType.get(directory);\n    };\n\n    const validate = <T extends BaseEntity>(entity: T): ValidationResult<T> => {\n        const registered = schemas.get(entity.type);\n\n        if (!registered) {\n            return {\n                success: false,\n                errors: [{ path: 'type', message: `Unknown entity type: ${entity.type}` }],\n            };\n        }\n\n        // Schema validation\n        const schemaResult = validateEntity(registered.schema, entity);\n        if (!schemaResult.success) {\n            return schemaResult as ValidationResult<T>;\n        }\n\n        // Custom validation\n        if (registered.customValidator) {\n            return registered.customValidator(entity) as ValidationResult<T>;\n        }\n\n        return { success: true, data: entity };\n    };\n\n    const validateAs = <T extends BaseEntity>(\n        type: string,\n        data: unknown\n    ): ValidationResult<T> => {\n        const registered = schemas.get(type);\n\n        if (!registered) {\n            return {\n                success: false,\n                errors: [{ path: 'type', message: `Unknown entity type: ${type}` }],\n            };\n        }\n\n        // Add type to data if missing (for convenience when loading from files)\n        const withType = typeof data === 'object' && data !== null\n            ? { ...data, type }\n            : data;\n\n        return validateEntity(registered.schema, withType) as ValidationResult<T>;\n    };\n\n    return {\n        register,\n        registerAll,\n        get,\n        has,\n        types,\n        getDirectoryName,\n        getTypeFromDirectory,\n        validate,\n        validateAs,\n    };\n};\n"],"names":["derivePluralName","type","endsWith","slice","createSchemaRegistry","schemas","Map","directoryToType","register","options","schema","pluralName","customValidator","plural","registered","set","registerAll","schemaMap","Object","entries","get","has","types","Array","from","keys","getDirectoryName","getTypeFromDirectory","directory","validate","entity","success","errors","path","message","schemaResult","validateEntity","data","validateAs","withType"],"mappings":"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"}

package/dist/schema/validation.d.ts

@@ -0,0 +1,26 @@
+import { z, ZodError } from 'zod';
+import { BaseEntity } from './base';
+export interface ValidationResult<T> {
+    success: boolean;
+    data?: T;
+    errors?: Array<{
+        path: string;
+        message: string;
+    }>;
+}
+/**
+ * Validate that an object satisfies at least the base entity contract.
+ */
+export declare const validateBaseEntity: (data: unknown) => ValidationResult<BaseEntity>;
+/**
+ * Validate data against a specific schema.
+ */
+export declare const validateEntity: <T extends BaseEntity>(schema: z.ZodType<T>, data: unknown) => ValidationResult<T>;
+/**
+ * Check if data extends the base entity (has id, name, type).
+ */
+export declare const isBaseEntity: (data: unknown) => data is BaseEntity;
+/**
+ * Format Zod errors into a readable message.
+ */
+export declare const formatValidationErrors: (errors: ZodError) => string;

package/dist/schema/validation.js

@@ -0,0 +1,51 @@
+import { BaseEntitySchema } from './base.js';
+
+/**
+ * Validate that an object satisfies at least the base entity contract.
+ */ const validateBaseEntity = (data)=>{
+    const result = BaseEntitySchema.safeParse(data);
+    if (result.success) {
+        return {
+            success: true,
+            data: result.data
+        };
+    }
+    return {
+        success: false,
+        errors: result.error.issues.map((e)=>({
+                path: e.path.join('.'),
+                message: e.message
+            }))
+    };
+};
+/**
+ * Validate data against a specific schema.
+ */ const validateEntity = (schema, data)=>{
+    const result = schema.safeParse(data);
+    if (result.success) {
+        return {
+            success: true,
+            data: result.data
+        };
+    }
+    return {
+        success: false,
+        errors: result.error.issues.map((e)=>({
+                path: e.path.join('.'),
+                message: e.message
+            }))
+    };
+};
+/**
+ * Check if data extends the base entity (has id, name, type).
+ */ const isBaseEntity = (data)=>{
+    return validateBaseEntity(data).success;
+};
+/**
+ * Format Zod errors into a readable message.
+ */ const formatValidationErrors = (errors)=>{
+    return errors.issues.map((e)=>`${e.path.join('.')}: ${e.message}`).join('; ');
+};
+
+export { formatValidationErrors, isBaseEntity, validateBaseEntity, validateEntity };
+//# sourceMappingURL=validation.js.map