@seedprotocol/sdk 0.7.3 → 0.7.4-next.784.g879c6a3

package/dist/{index-8O3Uow-Y.js → errors-Cl8rbtKR.js}

@@ -1,10 +1,10 @@
 import { fromCallback, fromPromise, setup, assign, createActor } from 'xstate';
-import { E as BaseDb, s as models, u as properties, $ as generateId, aF as isInternalSchema, aG as writeModelToDb, aH as writePropertyToDb, aI as addSchemaToDb, q as modelSchemas, z as schemas, F as AmbiguousModelError, aJ as renameModelInDb, a as TProperty } from './BasePathResolver-Cm4apKRb.js';
+import { E as BaseDb, s as models, u as properties, $ as generateId, aF as isInternalSchema, aG as writeModelToDb, aH as writePropertyToDb, aI as addSchemaToDb, q as modelSchemas, z as schemas, F as AmbiguousModelError, aJ as renameModelInDb, a as TProperty } from './BasePathResolver-DxdS0wJ0.js';
 import { eq, and, isNull, or } from 'drizzle-orm';
 import debug from 'debug';
-import { n as waitForEntityIdle, D as DEFAULT_READY_TIMEOUT_MS, $ as getInvariantSafePropertyDescriptor, q as findEntity, C as ClientManagerState, I as Item, a0 as clearDestroySubscriptions, t as forceRemoveFromCaches, a1 as unloadEntity, u as runDestroyLifecycle } from './Item-DBFchXpC.js';
-import { k as getClient } from './ClientManager-i3nJASkg.js';
-import { modelPropertiesToObject } from './model-DGMe-TTm.js';
+import { n as waitForEntityIdle, D as DEFAULT_READY_TIMEOUT_MS, $ as getInvariantSafePropertyDescriptor, q as findEntity, C as ClientManagerState, I as Item, a0 as clearDestroySubscriptions, t as forceRemoveFromCaches, a1 as unloadEntity, u as runDestroyLifecycle } from './Item-cq9VcsAY.js';
+import { k as getClient } from './ClientManager-De-vKHGe.js';
+import { modelPropertiesToObject } from './model-oHA3YhOd.js';
 import { toSnakeCase } from 'drizzle-orm/casing';
 import { Type } from '@sinclair/typebox';
 
@@ -35,7 +35,7 @@ const createPropertyInstances = async (propertyFileIds) => {
         return;
     }
     try {
-        const mod = await import('./ModelProperty-BS49g01Y.js');
+        const mod = await import('./ModelProperty-DuuoFXaC.js');
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$7('createPropertyInstances: ModelProperty not available from dynamic import');
@@ -101,11 +101,11 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context }, self })
                 if (!modelRecord) {
                     // Model names are only unique per schema: prefer this schema's row, and otherwise only
                     // consider same-name rows that no schema claims yet (never another schema's model).
-                    const _mod_0 = await import('./BasePathResolver-Cm4apKRb.js');
-                    const _ns_0 = _mod_0.b0;
+                    const _mod_0 = await import('./BasePathResolver-DxdS0wJ0.js');
+                    const _ns_0 = _mod_0.b1;
                     const { modelSchemas } = _ns_0;
-                    const _mod_1 = await import('./BasePathResolver-Cm4apKRb.js');
-                    const _ns_1 = _mod_1.a$;
+                    const _mod_1 = await import('./BasePathResolver-DxdS0wJ0.js');
+                    const _ns_1 = _mod_1.b0;
                     const { schemas: schemasTable } = _ns_1;
                     let dbModels = await db
                         .select({
@@ -252,7 +252,7 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context }, self })
         // Step 2: Fallback to Schema context (only if database doesn't have the model)
         // This handles the case where model exists in schema file but not yet in database
         try {
-            const _mod_2 = await import('./Schema-CpMNEnUO.js');
+            const _mod_2 = await import('./Schema-Dc5EA8Yb.js');
             const _ns_2 = _mod_2.b;
             const schemaMod = _ns_2;
             const { Schema } = schemaMod;
@@ -403,12 +403,12 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context }, self })
                     }
                     // Also check database for models (in case they're persisted but not in Schema context)
                     if (db) {
-                        const _mod_3 = await import('./BasePathResolver-Cm4apKRb.js');
-                        const _ns_3 = _mod_3.b0;
+                        const _mod_3 = await import('./BasePathResolver-DxdS0wJ0.js');
+                        const _ns_3 = _mod_3.b1;
                         const modelSchemaSchemaMod = _ns_3;
                         const { modelSchemas } = modelSchemaSchemaMod;
-                        const _mod_4 = await import('./BasePathResolver-Cm4apKRb.js');
-                        const _ns_4 = _mod_4.a$;
+                        const _mod_4 = await import('./BasePathResolver-DxdS0wJ0.js');
+                        const _ns_4 = _mod_4.b0;
                         const schemaSchemaMod = _ns_4;
                         const { schemas: schemasTable } = schemaSchemaMod;
                         // Query all models for this schema to check for duplicates (case-insensitive)
@@ -503,7 +503,7 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context }, self })
         }
         // Mark schema as draft when a new model is created so saveNewVersion() can persist it
         try {
-            const _mod_5 = await import('./Schema-CpMNEnUO.js');
+            const _mod_5 = await import('./Schema-Dc5EA8Yb.js');
             const _ns_5 = _mod_5.b;
             const schemaMod = _ns_5;
             const { Schema } = schemaMod;
@@ -551,10 +551,10 @@ const validateModel = fromCallback(({ sendBack, input: { context }, self }) => {
     const _validateModel = async () => {
         try {
             // Use dynamic imports to break circular dependencies
-            const validationServiceMod = await import('./SchemaValidationService-DieV4KL-.js');
+            const validationServiceMod = await import('./SchemaValidationService-DViJ056F.js');
             const { SchemaValidationService } = validationServiceMod;
             const validationService = new SchemaValidationService();
-            const _mod_6 = await import('./Schema-CpMNEnUO.js');
+            const _mod_6 = await import('./Schema-Dc5EA8Yb.js');
             const _ns_6 = _mod_6.b;
             const schemaMod = _ns_6;
             const { Schema } = schemaMod;
@@ -673,7 +673,7 @@ const createModelProperties = fromCallback(({ sendBack, input, self }) => {
             return;
         }
         logger$5(`Creating ${Object.keys(propertyDefinitions).length} properties for model "${modelName}" (id: ${_dbId})`);
-        const mod = await import('./ModelProperty-BS49g01Y.js');
+        const mod = await import('./ModelProperty-DuuoFXaC.js');
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$5('ModelProperty not available from dynamic import');
@@ -698,8 +698,8 @@ const createModelProperties = fromCallback(({ sendBack, input, self }) => {
                 : undefined;
             // Otherwise use provided ID or generate a random one
             // IDs should be generated in the import process before creating properties
-            const _mod_7 = await import('./BasePathResolver-Cm4apKRb.js');
-            const _ns_7 = _mod_7.b4;
+            const _mod_7 = await import('./BasePathResolver-DxdS0wJ0.js');
+            const _ns_7 = _mod_7.b5;
             const { generateId } = _ns_7;
             const propertyFileId = propData.id || propertyRecord?.schemaFileId || generateId();
             logger$5(`Creating property "${propName}" with fileId "${propertyFileId}"`);
@@ -716,8 +716,8 @@ const createModelProperties = fromCallback(({ sendBack, input, self }) => {
                     }
                     else if (refModelName) {
                         // Fallback: resolve the ref by name within this model's schema
-                        const _mod_8 = await import('./BasePathResolver-Cm4apKRb.js');
-                        const _ns_8 = _mod_8.b1;
+                        const _mod_8 = await import('./BasePathResolver-DxdS0wJ0.js');
+                        const _ns_8 = _mod_8.b2;
                         const { resolveModelRecord } = _ns_8;
                         const refModelRecord = await resolveModelRecord(refModelName, { schemaName }, db);
                         if (refModelRecord?.id) {
@@ -754,6 +754,10 @@ const createModelProperties = fromCallback(({ sendBack, input, self }) => {
                 localStorageDir: propData.localStorageDir ?? propertyRecord?.localStorageDir ?? undefined,
                 filenameSuffix: propData.filenameSuffix ?? propertyRecord?.filenameSuffix ?? undefined,
                 required: propData.required,
+                // Rules defined in code live only on the instance (the properties table has no column
+                // for them); getPropertySchema reads them from here when no schema file has them.
+                validation: propData.validation,
+                htmlEmbeddedDataUriPolicy: propData.htmlEmbeddedDataUriPolicy,
                 _propertyFileId: propertyFileId, // Store schemaFileId for getById() lookups
                 _dbId: propertyRecord?.schemaFileId === propertyFileId ? propertyRecord.id : undefined, // Already persisted: skip the write
             }, { schemaName }); // Use 'as any' because _propertyFileId is not in TProperty type
@@ -785,6 +789,12 @@ const createModelProperties = fromCallback(({ sendBack, input, self }) => {
  */
 let epoch = 0;
 const lastEvictionBySchema = new Map();
+// Schemas whose destroy() is still running (by name)
+const destroyingSchemas = new Map();
+// Single models destroyed (Model.destroy), by modelFileId
+const lastDestroyByModelId = new Map();
+// Models whose destroy() is still deleting their rows
+const destroyingModelIds = new Map();
 function currentEvictionEpoch() {
     return epoch;
 }
@@ -793,15 +803,73 @@ function recordSchemaEviction(schemaName) {
     epoch += 1;
     lastEvictionBySchema.set(schemaName, epoch);
 }
-/** True when the schema's instances were evicted after `since` (an epoch from currentEvictionEpoch). */
+/**
+ * Called by Schema.destroy before it evicts the schema's models; `finishSchemaDestroy` once its rows
+ * are gone. The schema's actor stays live until then, and work it starts meanwhile (its live query
+ * reading a model row the drained write just landed) captures an epoch after the eviction, so the
+ * epoch alone can't tell it to stay away.
+ */
+function recordSchemaDestroy(schemaName) {
+    recordSchemaEviction(schemaName);
+    destroyingSchemas.set(schemaName, (destroyingSchemas.get(schemaName) ?? 0) + 1);
+}
+function finishSchemaDestroy(schemaName) {
+    const remaining = (destroyingSchemas.get(schemaName) ?? 1) - 1;
+    if (remaining > 0)
+        destroyingSchemas.set(schemaName, remaining);
+    else
+        destroyingSchemas.delete(schemaName);
+    // Work that read a row during the destroy and checks after it must still see the eviction
+    recordSchemaEviction(schemaName);
+}
+/**
+ * True when the schema is being destroyed, or its instances were evicted after `since` (an epoch
+ * from currentEvictionEpoch).
+ */
 function schemaEvictedSince(schemaName, since) {
-    if (epoch === since || !schemaName)
+    if (!schemaName)
+        return false;
+    if (destroyingSchemas.has(schemaName))
+        return true;
+    if (epoch === since)
         return false;
     return (lastEvictionBySchema.get(schemaName) ?? 0) > since;
 }
-/** True when any schema was evicted after `since` (cheap check before looking up which schemas apply). */
+/**
+ * Called by Model.destroy before it clears the caches; `finishModelDestroy` once its rows are gone.
+ * Until then a lookup by id still finds the row, so it must not re-cache the model either.
+ */
+function recordModelDestroy(modelFileId) {
+    epoch += 1;
+    lastDestroyByModelId.set(modelFileId, epoch);
+    destroyingModelIds.set(modelFileId, (destroyingModelIds.get(modelFileId) ?? 0) + 1);
+}
+function finishModelDestroy(modelFileId) {
+    const remaining = (destroyingModelIds.get(modelFileId) ?? 1) - 1;
+    if (remaining > 0)
+        destroyingModelIds.set(modelFileId, remaining);
+    else
+        destroyingModelIds.delete(modelFileId);
+}
+/**
+ * True when the model is being destroyed, or was destroyed after `since` (an epoch from
+ * currentEvictionEpoch): a lookup that read its row must not create or cache an instance.
+ */
+function modelDestroyedSince(modelFileId, since) {
+    if (!modelFileId)
+        return false;
+    if (destroyingModelIds.has(modelFileId))
+        return true;
+    if (epoch === since)
+        return false;
+    return (lastDestroyByModelId.get(modelFileId) ?? 0) > since;
+}
+/**
+ * True when any schema was evicted after `since` or is being destroyed (cheap check before looking up
+ * which schemas apply).
+ */
 function anyEvictionSince(since) {
-    return epoch !== since;
+    return epoch !== since || destroyingSchemas.size > 0;
 }
 
 const logger$4 = debug('seedSdk:write:validateEntity');
@@ -817,7 +885,7 @@ const validateEntity = fromPromise(async ({ input }) => {
     const evictionEpoch = currentEvictionEpoch();
     /** The schema to validate against; throws (validation then skips the schema check) once it was evicted. */
     const schemaForValidation = async (schemaName) => {
-        const _mod_9 = await import('./Schema-CpMNEnUO.js');
+        const _mod_9 = await import('./Schema-Dc5EA8Yb.js');
         const _ns_9 = _mod_9.b;
         const { Schema } = _ns_9;
         if (schemaEvictedSince(schemaName, evictionEpoch)) {
@@ -835,7 +903,7 @@ const validateEntity = fromPromise(async ({ input }) => {
                 const structureMsg = `[validateEntity] Validating model structure`;
                 logger$4(structureMsg);
                 // Use existing Model validation
-                const validationServiceMod = await import('./SchemaValidationService-DieV4KL-.js');
+                const validationServiceMod = await import('./SchemaValidationService-DViJ056F.js');
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate model structure
@@ -885,7 +953,7 @@ const validateEntity = fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'modelProperty') {
                 // Use existing ModelProperty validation
-                const validationServiceMod = await import('./SchemaValidationService-DieV4KL-.js');
+                const validationServiceMod = await import('./SchemaValidationService-DViJ056F.js');
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate property structure
@@ -925,7 +993,7 @@ const validateEntity = fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'schema') {
                 // Schema validation - use existing validation
-                const validationServiceMod = await import('./SchemaValidationService-DieV4KL-.js');
+                const validationServiceMod = await import('./SchemaValidationService-DViJ056F.js');
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 const schemaResult = validationService.validateSchema(entityInput.entityData);
@@ -1014,7 +1082,7 @@ const writeToDatabase = fromCallback(({ sendBack, input }) => {
                 // initial write completes is not overwritten by the stale requestWrite payload.
                 let dataToWrite = input.entityData;
                 try {
-                    const mod = await import('./ModelProperty-BS49g01Y.js');
+                    const mod = await import('./ModelProperty-DuuoFXaC.js');
                     const ModelProperty = mod?.ModelProperty ?? mod?.default;
                     if (ModelProperty && typeof ModelProperty.getById === 'function') {
                         const instance = ModelProperty.getById(input.entityId);
@@ -1408,7 +1476,7 @@ const modelMachine = setup({
                                 // Create ModelProperty instances for any new property IDs
                                 if (Array.isArray(newPropertyIds) && newPropertyIds.length > 0) {
                                     // Import and create instances asynchronously (fire-and-forget)
-                                    import('./ModelProperty-BS49g01Y.js').then(({ ModelProperty }) => {
+                                    import('./ModelProperty-DuuoFXaC.js').then(({ ModelProperty }) => {
                                         if (self.getSnapshot().status === 'stopped')
                                             return;
                                         const createPromises = newPropertyIds.map(async (propertyFileId) => {
@@ -1908,12 +1976,33 @@ const getModelsData = async (schemaIdentifier) => {
     return rows;
 };
 
+/**
+ * Errors from draft saves that assignment starts in the background (schema/model renames and
+ * tracked-property edits). Nothing awaits those saves, so the error is kept for `lastSaveError`
+ * instead of only being logged. Keyed by the instance's service, which the instance and its
+ * proxy share.
+ */
+const draftSaveErrors = new WeakMap();
+function getDraftSaveError(service) {
+    return draftSaveErrors.get(service);
+}
+/** Run a background draft save, recording its failure (or clearing an earlier one on success). */
+function trackDraftSave(service, save, label) {
+    save.then(() => {
+        draftSaveErrors.delete(service);
+    }, (error) => {
+        const recorded = error instanceof Error ? error : new Error(String(error));
+        draftSaveErrors.set(service, recorded);
+        console.warn(`[seed] ${label}: draft save failed (see lastSaveError):`, recorded.message);
+    });
+}
+
 const logger = debug('seedSdk:model:Model');
 const saveDraftLogger = debug('seedSdk:model:saveDraftToDb');
 // Lazy import cache for ModelProperty to avoid circular dependency
 // Eagerly start loading to minimize delay on first access
 let ModelPropertyClass = null;
-const modelPropertyImportPromise = import('./ModelProperty-BS49g01Y.js')
+const modelPropertyImportPromise = import('./ModelProperty-DuuoFXaC.js')
     .then(module => {
     ModelPropertyClass = module.ModelProperty;
     return ModelPropertyClass;
@@ -2356,9 +2445,7 @@ class Model {
                             propertyKey: 'modelName',
                         });
                         // Save draft to database immediately so changes persist
-                        target._saveDraftToDb(oldName, newName).catch((error) => {
-                            logger(`Failed to save draft to database: ${error instanceof Error ? error.message : String(error)}`);
-                        });
+                        trackDraftSave(target._service, target._saveDraftToDb(oldName, newName), `Model "${newName}"`);
                         // NOTE: Schema is not notified of model name changes during edits.
                         // Schema will read from Model instances when persisting/saving.
                     }
@@ -2868,9 +2955,11 @@ class Model {
                         .limit(1);
                     const record = rows[0];
                     if (record?.modelName && record.schemaName && record.modelFileId) {
-                        // Its schema was evicted while we read the row: don't bring the model back.
+                        // Its schema was evicted, or it was destroyed, while we read the row: don't bring it back.
                         if (schemaEvictedSince(record.schemaName, evictionEpoch))
                             return undefined;
+                        if (modelDestroyedSince(record.modelFileId, evictionEpoch))
+                            return undefined;
                         return this.create(record.modelName, record.schemaName, { id: record.modelFileId });
                     }
                 }
@@ -2904,8 +2993,8 @@ class Model {
             const evictionEpoch = options?.evictionEpoch ?? currentEvictionEpoch();
             try {
                 // Query model by name (throws AmbiguousModelError when several schemas define it)
-                const _mod_10 = await import('./BasePathResolver-Cm4apKRb.js');
-                const _ns_10 = _mod_10.b1;
+                const _mod_10 = await import('./BasePathResolver-DxdS0wJ0.js');
+                const _ns_10 = _mod_10.b2;
                 const { resolveModelRecord } = _ns_10;
                 const resolved = await resolveModelRecord(modelName, {}, db);
                 if (!resolved?.schemaFileId) {
@@ -2929,10 +3018,13 @@ class Model {
                 if (!record.modelName || !record.schemaName || !record.modelFileId) {
                     return undefined;
                 }
-                // Its schema was evicted while we read the row: don't bring the model back.
+                // Its schema was evicted, or it was destroyed, while we read the row: don't bring it back.
                 if (schemaEvictedSince(record.schemaName, evictionEpoch)) {
                     return undefined;
                 }
+                if (modelDestroyedSince(record.modelFileId, evictionEpoch)) {
+                    return undefined;
+                }
                 // Create model instance (will be cached)
                 return this.create(record.modelName, record.schemaName, {
                     id: record.modelFileId, // id is now the schemaFileId (string)
@@ -2999,6 +3091,11 @@ class Model {
                 logger(`Model.createById: schema "${schemaName}" was evicted during the lookup of "${modelFileId}"`);
                 return undefined;
             }
+            // Destroyed while we read the row: destroy() clears the caches before it deletes the rows
+            if (modelDestroyedSince(modelFileId, evictionEpoch)) {
+                logger(`Model.createById: model "${modelFileId}" was destroyed during the lookup`);
+                return undefined;
+            }
             // Step 3: Create model using existing create method (which will handle caching)
             logger(`Model.createById: Creating model "${modelName}" in schema "${schemaName}" from ID "${modelFileId}"`);
             return this.create(modelName, schemaName, {
@@ -3076,10 +3173,13 @@ class Model {
                 if (!record.modelName || !record.schemaName || !record.modelFileId) {
                     continue;
                 }
-                // Its schema was evicted while we read the rows: don't bring its models back.
+                // Its schema was evicted, or the model destroyed, while we read the rows: don't bring it back.
                 if (schemaEvictedSince(record.schemaName, evictionEpoch)) {
                     continue;
                 }
+                if (modelDestroyedSince(record.modelFileId, evictionEpoch)) {
+                    continue;
+                }
                 // Check cache first
                 const cached = this.getById(record.modelFileId);
                 if (cached) {
@@ -3373,6 +3473,10 @@ class Model {
     get status() {
         return this._getSnapshot().value;
     }
+    /** The error from the last draft save a rename started, or undefined once a later one succeeds. */
+    get lastSaveError() {
+        return getDraftSaveError(this._service);
+    }
     get validationErrors() {
         return this._getSnapshotContext()._validationErrors || [];
     }
@@ -3611,6 +3715,9 @@ class Model {
         const schemaName = context.schemaName;
         const nameKey = schemaName && modelName ? `${schemaName}:${modelName}` : '';
         clearDestroySubscriptions(this, { instanceState: modelInstanceState });
+        // Before the caches are cleared, so a lookup by id already reading the row doesn't re-cache it
+        if (modelFileId)
+            recordModelDestroy(modelFileId);
         const cacheKeys = [];
         if (modelFileId)
             cacheKeys.push(modelFileId);
@@ -3624,7 +3731,7 @@ class Model {
                 Model.instanceCache,
             ],
         });
-        await runDestroyLifecycle(this, {
+        const destroying = runDestroyLifecycle(this, {
             getService: (instance) => instance._service,
             doDestroy: async () => {
                 const db = BaseDb.getAppDb();
@@ -3638,7 +3745,7 @@ class Model {
                         .limit(1);
                     if (modelRecords.length > 0) {
                         const modelId = modelRecords[0].id;
-                        const { detachModelRows } = await import('./detachRowsBeforeDelete-S0q-DJPT.js');
+                        const { detachModelRows } = await import('./detachRowsBeforeDelete-YRSZY6dO.js');
                         await detachModelRows(db, [typeof modelId === 'string' ? parseInt(modelId, 10) : modelId]);
                         await db.delete(modelSchemas).where(eq(modelSchemas.modelId, modelId));
                         await db
@@ -3649,7 +3756,7 @@ class Model {
                 }
                 if (schemaName && modelName) {
                     // Imported here, not at module load: Model and Schema import each other.
-                    const _mod_11 = await import('./Schema-CpMNEnUO.js');
+                    const _mod_11 = await import('./Schema-Dc5EA8Yb.js');
                     const _ns_11 = _mod_11.b;
                     const { Schema } = _ns_11;
                     const schema = Schema.create(schemaName, { waitForReady: false });
@@ -3664,6 +3771,13 @@ class Model {
                 }
             },
         });
+        try {
+            await destroying;
+        }
+        finally {
+            if (modelFileId)
+                finishModelDestroy(modelFileId);
+        }
     }
     /**
      * Set up liveQuery subscription to watch for property changes in the database
@@ -3686,8 +3800,8 @@ class Model {
                             return undefined;
                         }
                         // Model names are only unique per schema: find this model's row by its id (schemaFileId).
-                        const _mod_12 = await import('./BasePathResolver-Cm4apKRb.js');
-                        const _ns_12 = _mod_12.b1;
+                        const _mod_12 = await import('./BasePathResolver-DxdS0wJ0.js');
+                        const _ns_12 = _mod_12.b2;
                         const { resolveModelRecord } = _ns_12;
                         const modelRecord = await resolveModelRecord(modelName, { modelFileId: context.id, schemaName: context.schemaName }, db);
                         if (!modelRecord?.id) {
@@ -3891,5 +4005,35 @@ var Model$1 = /*#__PURE__*/Object.freeze({
 const TModelValues = Type.Record(Type.String(), Type.Any());
 const TModelSchema = Type.Record(Type.String(), TProperty);
 
-export { ConflictError as C, Model as M, TModelSchema as T, TModelValues as a, anyEvictionSince as b, currentEvictionEpoch as c, setupEntityLiveQuery as d, writeToDatabase$1 as e, Model$1 as f, isActorStopped as i, schemaEvictedSince as s, writeProcessMachine as w };
-//# sourceMappingURL=index-8O3Uow-Y.js.map
+/**
+ * Thrown by Item.create when values don't fit the model: unknown keys, wrong types, or values
+ * that break the property's validation rules. Nothing is written.
+ */
+class ItemCreateValidationError extends Error {
+    constructor(modelName, problems) {
+        super(`Cannot create ${modelName}: ` + problems.map((p) => `${p.property}: ${p.message}`).join('; '));
+        this.name = 'ItemCreateValidationError';
+        this.modelName = modelName;
+        this.problems = problems;
+        Object.setPrototypeOf(this, ItemCreateValidationError.prototype);
+    }
+}
+/** Thrown by Item.create when no model with that name exists (in the given schema, if any). */
+class UnknownModelError extends Error {
+    constructor(modelName, schemaName) {
+        super(`Model "${modelName}" not found${schemaName ? ` in schema "${schemaName}"` : ''}.`);
+        this.name = 'UnknownModelError';
+        this.modelName = modelName;
+        this.schemaName = schemaName;
+        Object.setPrototypeOf(this, UnknownModelError.prototype);
+    }
+}
+
+var errors = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    ItemCreateValidationError: ItemCreateValidationError,
+    UnknownModelError: UnknownModelError
+});
+
+export { ConflictError as C, ItemCreateValidationError as I, Model as M, TModelSchema as T, UnknownModelError as U, TModelValues as a, anyEvictionSince as b, currentEvictionEpoch as c, setupEntityLiveQuery as d, writeToDatabase$1 as e, finishSchemaDestroy as f, getDraftSaveError as g, Model$1 as h, isActorStopped as i, errors as j, recordSchemaDestroy as r, schemaEvictedSince as s, trackDraftSave as t, writeProcessMachine as w };
+//# sourceMappingURL=errors-Cl8rbtKR.js.map