@seedprotocol/sdk 0.7.7 → 0.7.8-next.1034.g2acd2a2

package/dist/dist/{Item-D6j0IvBP.d.ts → Item-BiMHgg-_.d.ts}

@@ -1,19 +1,35 @@
 /**
- * Release one reference to a cached entity instance. When none remain, remove it from the
- * caches, clean up its subscriptions and stop its service
+ * Per-instance state for an entity (liveQuery subscriptions and the like), keyed by the entity's
+ * actor. An entity's raw instance and its reactive proxy are different objects that share one
+ * actor. State set from the constructor (`this` = raw instance) must be found again from methods
+ * called on the proxy (`this` = proxy), so a WeakMap keyed by the instance misses there.
  *
- * @param instance - Entity instance to unload
- * @param config - Unload configuration
+ * `getService()` must return the actor before the first `set`.
  */
-declare function unloadEntity(instance: any, config: any): void;
-declare function getPublishExecutor(): any;
-declare function getRevokeExecutor(): any;
+declare class ActorKeyedState {
+    states: WeakMap<object, any>;
+    get(instance: any): any;
+    set(instance: any, state: any): this;
+    delete(instance: any): boolean;
+    has(instance: any): boolean;
+}
+declare function getGetPublisherForNewSeeds(): any;
+/**
+ * Metadata rows of a seed numbered per property_name in reader order (`rowNum = 1` is the value to
+ * show): live rows before revoked ones, then newest first. See `compareMetadataRowsLatestFirst`.
+ */
+declare function getMetadataLatest({ seedLocalId, seedUid }: {
+    seedLocalId: any;
+    seedUid: any;
+}): any;
 declare var ClientManagerState: any;
 /**
  * Default readyTimeout for create/find/all with waitForReady. Loads that touch OPFS and the DB can take
  * several seconds on slow devices and CI runners; a load that is really stuck still errors.
  */
 declare const DEFAULT_READY_TIMEOUT_MS: 15000;
+declare function getPublishExecutor(): any;
+declare function getRevokeExecutor(): any;
 /** @deprecated See UploadExecutor. */
 declare function getUploadExecutor(): any;
 /**
@@ -29,23 +45,18 @@ declare function getUploadExecutor(): any;
  * (batched resolution aligned with `getLatestPublishedVersionRow`).
  */
 declare function getVersionData$1(): any;
-/**
- * Local draft that has never been attested: no publisher, no real uid, no attestationRaw.
- */
-declare function isLocalUnsealedDraft(row: any): boolean;
-/**
- * Shared ownership predicate.
- * - A local unsealed draft (never given a publisher) is owned whatever the owned addresses are:
- *   it belongs to no wallet yet, and the next wallet to connect claims it (claimUnpublishedDrafts).
- * - Any other row is owned when its publisher (or attester) is in the owned addresses.
- */
-declare function isSeedRowOwned(row: any, ownedAddresses: any): boolean;
 declare class Item {
     /** Prefer local id so list rows (local + uid) resolve the same cache entry as early draft loads. */
     static findItemInstanceCacheEntryByProps(props: any): any;
     static findItemInstanceCacheEntryById(id: any): any;
     static collectInstanceCacheKeysForInstance(instance: any): any[];
     static registerItemInInstanceCache(instance: any): void;
+    /**
+     * Wraps a new instance in its reactive proxy: tracked names read from and write to the actor's
+     * context, and the model's property names (`item.title`, or `item.html` for `htmlId`) read and
+     * write their ItemProperty's value.
+     */
+    static wrapInProxy(instance: any): any;
     /**
      * Sets a tracked context property from the proxy. Setting `seedUid` to a different uid means a
      * new seed attestation (publishing again after unpublish): the revocation belonged to the old
@@ -59,6 +70,11 @@ declare class Item {
      * `propertyInstances` is merged (an item with a version but no property instances yet).
      */
     static isItemSnapshotReadyForRead(snap: any): boolean;
+    /**
+     * The cached Item for a seedLocalId or seedUid, in any state, without taking a hold. For SDK code
+     * that reads or messages the item and doesn't hand it to a caller.
+     */
+    static peek(id: any): any;
     /**
      * The cached Item for a seedLocalId or seedUid when it can be read right now: idle and hydrated,
      * so at least what `Item.find()` would wait for. Otherwise undefined. Unlike `getById`, it takes
@@ -193,13 +209,19 @@ declare class Item {
         };
     }, import("xstate").MetaObject>>;
     _subscription: import("xstate").Subscription;
-    _createPropertyInstance(props: any): void;
     /**
-     * Defines a property accessor on this Item that delegates get/set to the
-     * ItemProperty in context.propertyInstances at access time (so the correct
-     * instance is used after loadOrCreateItemSuccess merges DB-backed instances).
+     * The ItemProperty a model property name reads and writes on the item: by its name, or by its
+     * storage name (`html` finds `htmlId` and the other way round). Internal names don't resolve.
      */
-    _definePropertyAccessor(propertyName: any): void;
+    _findPropertyInstance(propertyName: any): any;
+    /** Every name `_findPropertyInstance` resolves: the stored names and their schema names. */
+    _propertyInstanceNames(): any[];
+    /**
+     * Writes an assigned seed uid to the item's seed row, so later loads and getPublishPayload see it.
+     * Writes run one after another per item, so the last assignment is the one that stays.
+     */
+    _persistSeedUid(seedUid: any): void;
+    _createPropertyInstance(props: any): void;
     get serviceContext(): {};
     /**
      * Get snapshot context from the service
@@ -279,21 +301,19 @@ declare namespace Item {
     let instanceCache: Map<any, any>;
     let CREATE_METADATA_KEYS: Set<string>;
 }
-/** SQL form of {@link isLocalUnsealedDraft} on `seeds`. */
-declare function localUnsealedDraftSql(): import("drizzle-orm").SQL<unknown> | undefined;
 /**
- * @deprecated Matches `seeds.publisher` only. Use {@link ownedSeedsSql}, which agrees
- * with {@link isSeedRowOwned} (empty owned → local unsealed drafts; attester fallback).
+ * Local draft that has never been attested: no publisher, no real uid, no attestationRaw.
  */
-declare function ownedPublisherSql(ownedAddresses: any): import("drizzle-orm").SQL<any>;
+declare function isLocalUnsealedDraft(row: any): boolean;
 /**
- * SQL for `addressFilter: 'owned'`: a row passes exactly when {@link isSeedRowOwned} is true.
- * - Local unsealed drafts always pass.
- * - Otherwise `lower(trim(publisher))` is in the owned set, or, when publisher is blank, the
- *   `attestationRaw.attester` ({@link resolvePublisherFromSeedRow}). `json_valid` guards
- *   `json_extract`, which throws on malformed JSON.
+ * Shared ownership predicate.
+ * - A local unsealed draft (never given a publisher) is owned whatever the owned addresses are:
+ *   it belongs to no wallet yet, and the next wallet to connect claims it (claimUnpublishedDrafts).
+ * - Any other row is owned when its publisher (or attester) is in the owned addresses.
  */
-declare function ownedSeedsSql(ownedAddresses: any): import("drizzle-orm").SQL<unknown> | undefined;
+declare function isSeedRowOwned(row: any, ownedAddresses: any): boolean;
+/** SQL form of {@link isLocalUnsealedDraft} on `seeds`. */
+declare function localUnsealedDraftSql(): import("drizzle-orm").SQL<unknown> | undefined;
 /**
  * Canonical "latest metadata row first" ordering, the one readers use to pick a property's value
  * from its rows across versions:
@@ -310,8 +330,11 @@ declare function ownedSeedsSql(ownedAddresses: any): import("drizzle-orm").SQL<u
  * out; keep those in sync.
  */
 declare const METADATA_LATEST_FIRST_ORDER_SQL: "(revoked_at IS NOT NULL), COALESCE(attestation_created_at, created_at) DESC, local_id DESC";
-/** The row readers show for each property name (first by {@link compareMetadataRowsLatestFirst}). */
-declare function pickLatestMetadataRowPerProperty(rows: any): any[];
+/**
+ * @deprecated Matches `seeds.publisher` only. Use {@link ownedSeedsSql}, which agrees
+ * with {@link isSeedRowOwned} (empty owned → local unsealed drafts; attester fallback).
+ */
+declare function ownedPublisherSql(ownedAddresses: any): import("drizzle-orm").SQL<any>;
 /**
  * Thrown by write operations (save, destroy, publish, unpublish) on an item none
  * of the client's addresses own. See isItemOwned for what counts as owned.
@@ -320,6 +343,16 @@ declare class OwnershipError extends Error {
     constructor(message?: string);
 }
 declare const PUBLISH_NOT_CONFIGURED_MESSAGE: "Publishing is not configured. item.publish() needs @seedprotocol/publish: call initPublish() from it, or mount <PublishProvider config={...}>, before publishing.";
+/**
+ * SQL for `addressFilter: 'owned'`: a row passes exactly when {@link isSeedRowOwned} is true.
+ * - Local unsealed drafts always pass.
+ * - Otherwise `lower(trim(publisher))` is in the owned set, or, when publisher is blank, the
+ *   `attestationRaw.attester` ({@link resolvePublisherFromSeedRow}). `json_valid` guards
+ *   `json_extract`, which throws on malformed JSON.
+ */
+declare function ownedSeedsSql(ownedAddresses: any): import("drizzle-orm").SQL<unknown> | undefined;
+/** The row readers show for each property name (first by {@link compareMetadataRowsLatestFirst}). */
+declare function pickLatestMetadataRowPerProperty(rows: any): any[];
 /** SQL form of {@link isPlaceholderUid}: null, `''`, `'NULL'`, or zero bytes32 (trimmed, any case). */
 declare function placeholderUidSql(column: any): import("drizzle-orm").SQL<unknown> | undefined;
 declare const propertyMachine: import("xstate").StateMachine<{}, import("xstate").AnyEventObject, {
@@ -405,28 +438,13 @@ declare function setPublishExecutor(executor: any): void;
 declare function setRevokeExecutor(executor: any): void;
 /** @deprecated See UploadExecutor. */
 declare function setUploadExecutor(executor: any): void;
-/**
- * Proxy [[GetOwnProperty]] that stays compatible with the target.
- * Never overrides an own descriptor, never invents on a non-extensible target,
- * and never promotes a prototype accessor to an own descriptor.
- */
-declare function getInvariantSafePropertyDescriptor(target: any, prop: any, invent: any): TypedPropertyDescriptor<any> | {
-    enumerable: boolean;
-    configurable: boolean;
-    value: any;
-    writable: any;
-} | undefined;
-/**
- * Shared helpers for entity destroy operations.
- * Used by Schema, Model, ModelProperty, Item, and ItemProperty destroy() methods.
- */
-/**
- * Unsubscribe liveQuery and any extra subscription (e.g. Item/ItemProperty _subscription).
- * Swallows errors so one failure doesn't block the rest.
- */
-declare function clearDestroySubscriptions(instance: any, config: any): void;
 declare class ItemProperty {
     static create(props: any, options: any): any;
+    /**
+     * Wraps a new instance in its reactive proxy: tracked names read from and write to the actor's
+     * context, and assigning `value` also sends it to the actor before the setter runs.
+     */
+    static wrapInProxy(instance: any): any;
     /**
      * The cached ItemProperty when it can be read right now (idle, not saving), the state
      * `ItemProperty.find()` waits for. Otherwise undefined. Unlike `find`, it takes no cache hold, so
@@ -437,21 +455,33 @@ declare class ItemProperty {
         seedLocalId: any;
         seedUid: any;
     }): any;
-    static find({ propertyName, seedLocalId, seedUid, modelName: modelNameOption, waitForReady, readyTimeout, }: {
+    /** Takes a hold on the instance it returns: release it with `unload()`. */
+    static find({ propertyName, seedLocalId, seedUid, modelName: modelNameOption, waitForReady, readyTimeout, hold, }: {
         propertyName: any;
         seedLocalId: any;
         seedUid: any;
         modelName: any;
         waitForReady?: boolean | undefined;
         readyTimeout?: number | undefined;
+        hold: any;
     }): Promise<any>;
     /**
      * Get all ItemProperty instances for an item.
      * Loads property data via getItemProperties, creates instances via create, optionally waits for idle.
+     * Takes a hold on each instance, as `create` does.
      */
     static all(params: any, options: any): Promise<any[]>;
+    /**
+     * @internal Takes one more hold on a cached, running instance, released with `unload()`. False
+     * (and no hold) when the instance isn't cached or was stopped.
+     */
+    static retain(instance: any): boolean;
     static cacheKey(seedLocalIdOrUid: any, propertyName: any): string;
-    /** Clears instance cache for an item (for test isolation when run in group). */
+    /**
+     * Drops an item's properties from the instance cache, under every key they're cached by. A dropped
+     * instance someone still holds keeps running but is detached: it doesn't re-key itself into the
+     * cache when its context changes, so the next lookup creates a fresh instance.
+     */
     static clearInstanceCacheForItem(seedLocalIdOrUid: any): void;
     constructor(initialValues: any);
     _isRelation: boolean;
@@ -674,6 +704,11 @@ declare class ItemProperty {
     get published(): boolean;
     subscribe(callback: any): import("xstate").Subscription;
     save(): Promise<void>;
+    /**
+     * Every cache key holding this instance: its item's local id and seed uid, and the name it had
+     * before a rename (List of relation). They share one entry.
+     */
+    _cacheKeys(): any[];
     unload(): void;
     /**
      * Destroy the item property: remove from caches, delete its metadata rows (every version of
@@ -686,6 +721,23 @@ declare namespace ItemProperty {
     let instanceCache_1: Map<any, any>;
     export { instanceCache_1 as instanceCache };
 }
+/**
+ * Shared helpers for entity destroy operations.
+ * Used by Schema, Model, ModelProperty, Item, and ItemProperty destroy() methods.
+ */
+/**
+ * Unsubscribe the entity's liveQueries and any extra subscription (e.g. Item/ItemProperty
+ * _subscription). Swallows errors so one failure doesn't block the rest.
+ */
+declare function clearDestroySubscriptions(instance: any, config: any): void;
+/**
+ * Release one reference to a cached entity instance. When none remain, remove it from the
+ * caches, clean up its subscriptions and stop its service
+ *
+ * @param instance - Entity instance to unload
+ * @param config - Unload configuration
+ */
+declare function unloadEntity(instance: any, config: any): void;
 declare var ClientManagerEvents: any;
 /**
  * Runs `fn` with a fresh read of metadata row `localId`, holding the lock of the file that row's
@@ -794,6 +846,12 @@ declare function getGetAdditionalSyncAddresses(): any;
  * "not revoked", like `seeds.revoked_at`.
  */
 declare function isVersionRevoked(revokedAt: any): boolean;
+/**
+ * Whether an actor has been stopped (unload, destroy, or Schema eviction). Async work started by an
+ * entity (DB lookups, retry timers) must check this before sending, since a stopped actor ignores
+ * events and XState warns about every one of them.
+ */
+declare function isActorStopped(actor: any): boolean;
 /**
  * Creates a reactive Proxy that intercepts property access and assignment
  * to read from and write to an actor service's context.
@@ -810,6 +868,22 @@ declare function isVersionRevoked(revokedAt: any): boolean;
  * The Proxy implementation preserves all methods via Reflect.get, so this is safe.
  */
 declare function createReactiveProxy(config: any): any;
+/**
+ * Common getters and utilities for entity classes
+ * These work with any entity that has a getService() method returning an XState actor
+ */
+/**
+ * Get the current state value from an entity's service
+ */
+/**
+ * Whether two references are the same entity: an instance and its reactive proxy are different
+ * objects that share one actor.
+ */
+declare function sameEntity(a: any, b: any): boolean;
+/**
+ * Parse List property values persisted as strings (JSON array or legacy comma-separated ids).
+ */
+declare function parseListPropertyValueFromStorage(raw: any): any;
 /**
  * Generic find implementation for entities
  *
@@ -819,15 +893,21 @@ declare function createReactiveProxy(config: any): any;
  * @returns Entity instance if found, undefined otherwise
  */
 declare function findEntity(config: any, params: any, options?: {}): Promise<any>;
+/**
+ * Rows per multi-row INSERT into `table` so the statement binds at most
+ * {@link SQLITE_DEFAULT_MAX_VARIABLE_NUMBER} parameters even with every column set.
+ */
+declare function rowsPerInsert(table: any): number;
+/**
+ * Runs `query` once per chunk of `values` (see {@link chunkValues}), one after another, and
+ * concatenates the rows. Use it for `inArray(column, values)` reads whose list can be large.
+ */
+declare function selectInBatches(values: any, query: any, size?: number): Promise<any[]>;
 /**
  * Remove the instance from all given caches by key, without refCount (always delete).
  * Works for both entry caches and index caches since the operation is only delete(key).
  */
 declare function forceRemoveFromCaches(instance: any, config: any): void;
-/**
- * Parse List property values persisted as strings (JSON array or legacy comma-separated ids).
- */
-declare function parseListPropertyValueFromStorage(raw: any): any;
 /**
  * Run the service event sequence and stop the service:
  * destroyStarted -> doDestroy -> (destroyError on failure) -> stop.
@@ -836,22 +916,14 @@ declare function parseListPropertyValueFromStorage(raw: any): any;
  * Event names must match what the entity machines expect.
  */
 declare function runDestroyLifecycle(instance: any, config: any): Promise<void>;
-/**
- * Rows per multi-row INSERT into `table` so the statement binds at most
- * {@link SQLITE_DEFAULT_MAX_VARIABLE_NUMBER} parameters even with every column set.
- */
-declare function rowsPerInsert(table: any): number;
-/**
- * Runs `query` once per chunk of `values` (see {@link chunkValues}), one after another, and
- * concatenates the rows. Use it for `inArray(column, values)` reads whose list can be large.
- */
-declare function selectInBatches(values: any, query: any, size?: number): Promise<any[]>;
 /**
  * A metadata row holds published content when it has a valid EAS attestation uid, or when sync
  * derived it from one (ItemStorage rows from a storage_transaction_id attestation: no uid of their
  * own, `derivedFromUid` set). Anything else is a local edit (or a row awaiting its uid backfill).
  */
 declare function isPublishedMetadataRow(row: any): boolean;
+/** Runs `write` once per chunk of `values`, one after another (deletes / updates with an `IN` list). */
+declare function writeInBatches(values: any, write: any, size?: number): Promise<void>;
 declare var MachineIds: any;
 declare function createNewItem({ modelName, modelFileId, ...propertyData }: {
     [x: string]: any;
@@ -862,8 +934,6 @@ declare function createNewItem({ modelName, modelFileId, ...propertyData }: {
     seedLocalId: any;
     versionLocalId: string;
 }>;
-/** Runs `write` once per chunk of `values`, one after another (deletes / updates with an `IN` list). */
-declare function writeInBatches(values: any, write: any, size?: number): Promise<void>;
 declare function getEasSchemaForItemProperty({ schemaUid, propertyName, easDataType, }: {
     schemaUid: any;
     propertyName: any;
@@ -877,15 +947,6 @@ declare function getEasSchemaForItemProperty({ schemaUid, propertyName, easDataT
         name: string;
     }>;
 } | undefined>;
-declare function getGetPublisherForNewSeeds(): any;
-/**
- * Metadata rows of a seed numbered per property_name in reader order (`rowNum = 1` is the value to
- * show): live rows before revoked ones, then newest first. See `compareMetadataRowsLatestFirst`.
- */
-declare function getMetadataLatest({ seedLocalId, seedUid }: {
-    seedLocalId: any;
-    seedUid: any;
-}): any;
 import { BehaviorSubject } from 'rxjs';
-export { unloadEntity as $, getPublishExecutor as A, getRevokeExecutor as B, ClientManagerState as C, DEFAULT_READY_TIMEOUT_MS as D, getUploadExecutor as E, getVersionData$1 as F, isLocalUnsealedDraft as G, isSeedRowOwned as H, Item as I, localUnsealedDraftSql as J, ownedPublisherSql as K, ownedSeedsSql as L, METADATA_LATEST_FIRST_ORDER_SQL as M, pickLatestMetadataRowPerProperty as N, OwnershipError as O, PUBLISH_NOT_CONFIGURED_MESSAGE as P, placeholderUidSql as Q, propertyMachine as R, publisherInAddressListSql as S, publisherIsInOwnedSet as T, setAdditionalSyncAddresses as U, setGetPublisherForNewSeeds as V, setPublishExecutor as W, setRevokeExecutor as X, setUploadExecutor as Y, getInvariantSafePropertyDescriptor as Z, clearDestroySubscriptions as _, ItemProperty as a, ClientManagerEvents as a0, withLockedItemStorageRow as a1, getItemStorageFilePath as a2, writeItemStorageFile as a3, resolvePublisherFromSeedRow as a4, getPropertyData$1 as a5, Item$1 as a6, ItemPropertySaveValidationError as b, assertItemOwned as c, waitForEntityIdle as d, compareMetadataRowsLatestFirst as e, getEasSchemaUidForModel as f, getItemData as g, getLatestPublishedVersionRow as h, isItemOwned as i, chunkValues as j, getGetAdditionalSyncAddresses as k, isVersionRevoked as l, createReactiveProxy as m, findEntity as n, forceRemoveFromCaches as o, parseListPropertyValueFromStorage as p, runDestroyLifecycle as q, rowsPerInsert as r, selectInBatches as s, isPublishedMetadataRow as t, MachineIds as u, createNewItem as v, writeInBatches as w, getEasSchemaForItemProperty as x, getGetPublisherForNewSeeds as y, getMetadataLatest as z };
-//# sourceMappingURL=Item-D6j0IvBP.d.ts.map
+export { ActorKeyedState as $, getGetPublisherForNewSeeds as A, getMetadataLatest as B, ClientManagerState as C, DEFAULT_READY_TIMEOUT_MS as D, getPublishExecutor as E, getRevokeExecutor as F, getUploadExecutor as G, getVersionData$1 as H, Item as I, isLocalUnsealedDraft as J, isSeedRowOwned as K, localUnsealedDraftSql as L, METADATA_LATEST_FIRST_ORDER_SQL as M, ownedPublisherSql as N, OwnershipError as O, PUBLISH_NOT_CONFIGURED_MESSAGE as P, ownedSeedsSql as Q, pickLatestMetadataRowPerProperty as R, placeholderUidSql as S, propertyMachine as T, publisherInAddressListSql as U, publisherIsInOwnedSet as V, setAdditionalSyncAddresses as W, setGetPublisherForNewSeeds as X, setPublishExecutor as Y, setRevokeExecutor as Z, setUploadExecutor as _, ItemProperty as a, clearDestroySubscriptions as a0, unloadEntity as a1, ClientManagerEvents as a2, withLockedItemStorageRow as a3, getItemStorageFilePath as a4, writeItemStorageFile as a5, resolvePublisherFromSeedRow as a6, getPropertyData$1 as a7, Item$1 as a8, ItemPropertySaveValidationError as b, assertItemOwned as c, waitForEntityIdle as d, compareMetadataRowsLatestFirst as e, getEasSchemaUidForModel as f, getItemData as g, getLatestPublishedVersionRow as h, isItemOwned as i, chunkValues as j, getGetAdditionalSyncAddresses as k, isVersionRevoked as l, isActorStopped as m, createReactiveProxy as n, sameEntity as o, parseListPropertyValueFromStorage as p, findEntity as q, rowsPerInsert as r, selectInBatches as s, forceRemoveFromCaches as t, runDestroyLifecycle as u, isPublishedMetadataRow as v, writeInBatches as w, MachineIds as x, createNewItem as y, getEasSchemaForItemProperty as z };
+//# sourceMappingURL=Item-BiMHgg-_.d.ts.map

package/dist/dist/Item-BiMHgg-_.d.ts.map

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

package/dist/dist/{ModelProperty-B52C3CQ2.d.ts → ModelProperty-C1Fzcnbm.d.ts}

@@ -312,4 +312,4 @@ export namespace ModelProperty {
     let idIndex: Map<any, any>;
     let pendingWrites: Map<any, any>;
 }
-//# sourceMappingURL=ModelProperty-B52C3CQ2.d.ts.map
+//# sourceMappingURL=ModelProperty-C1Fzcnbm.d.ts.map

package/dist/dist/{ModelProperty-B52C3CQ2.d.ts.map → ModelProperty-C1Fzcnbm.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"ModelProperty-B52C3CQ2.d.ts","sourceRoot":"","sources":["../ModelProperty-B52C3CQ2.js"],"names":[],"mappings":"AA+1BA;IAwZI,gDA+RC;IACD,+EAA+E;IAC/E,qEASC;IACD,8FAA8F;IAC9F,+DAmBC;IACD;;;;OAIG;IACH,0CAMC;IACD;;OAEG;IACH,yCAmBC;IACD;;;OAGG;IACH,mEAyFC;IACD;;;;;;OAMG;IACH,0DAwEC;IACD;;;;;OAKG;IACH;;;;qBAWC;IACD;;;OAGG;IACH,2DAqBC;IACD;;OAEG;IACH,kEAOC;IACD;;;;OAIG;IACH,8EAQC;IACD;;OAEG;IACH,qEAeC;IACD;;OAEG;IACH,kDAIC;IACD;;;OAGG;IACH,mDAEC;IAyGD;;;;OAIG;IACH,8DAwBC;IAppCD,2BAqBC;IApBG,2GAA2G;IAC3G,uBAA4C;IAY5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAEE;IAMN;;;OAGG;IACH,iCAIC;IACD;;;;;OAKG;IACH,+CA+GC;IACD;;;;;OAKG;IACH,wEAgCC;IACD;;;;OAIG;IACH,mEAuBC;IACD,6EAA6E;IAC7E;;;MAOC;IACD;;;OAGG;IACH;;;;;;;mBA6EC;IACD;;;OAGG;IACH,6CAiDC;IACD;;;OAGG;IACH,kEA8BC;IACD;;;OAGG;IACH,qCAKC;IAynBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAEC;IACD;;;;;;;;;;;;;;;;;;;;;;;;OAEC;IACD,0BAEC;IACD,+BAMC;IACD,iBAEC;IACD,oBAcC;IACD,4BAEC;IACD,uBAGC;IACD;;;OAGG;IACH,yBA8BC;IACD,aAaC;IACD;;;;;OAKG;IACH,wBAOC;IA+BD;;;;OAIG;IACH,eAmBC;IACD;;OAEG;IACH,yBAmEC;CACJ"}
+{"version":3,"file":"ModelProperty-C1Fzcnbm.d.ts","sourceRoot":"","sources":["../ModelProperty-C1Fzcnbm.js"],"names":[],"mappings":"AA21BA;IAyZI,gDA+RC;IACD,+EAA+E;IAC/E,qEAUC;IACD,8FAA8F;IAC9F,+DAmBC;IACD;;;;OAIG;IACH,0CAMC;IACD;;OAEG;IACH,yCAmBC;IACD;;;OAGG;IACH,mEAyFC;IACD;;;;;;OAMG;IACH,0DAyEC;IACD;;;;;OAKG;IACH;;;;qBAWC;IACD;;;OAGG;IACH,2DAqBC;IACD;;OAEG;IACH,kEAOC;IACD;;;;OAIG;IACH,8EAQC;IACD;;OAEG;IACH,qEAeC;IACD;;OAEG;IACH,kDAIC;IACD;;;OAGG;IACH,mDAEC;IAyGD;;;;OAIG;IACH,8DAwBC;IAvpCD,2BAqBC;IApBG,2GAA2G;IAC3G,uBAA4C;IAY5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAEE;IAMN;;;OAGG;IACH,iCAIC;IACD;;;;;OAKG;IACH,+CA+GC;IACD;;;;;OAKG;IACH,wEAgCC;IACD;;;;OAIG;IACH,mEAuBC;IACD,6EAA6E;IAC7E;;;MAOC;IACD;;;OAGG;IACH;;;;;;;mBA8EC;IACD;;;OAGG;IACH,6CAiDC;IACD;;;OAGG;IACH,kEA8BC;IACD;;;OAGG;IACH,qCAKC;IA2nBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAEC;IACD;;;;;;;;;;;;;;;;;;;;;;;;OAEC;IACD,0BAEC;IACD,+BAMC;IACD,iBAEC;IACD,oBAcC;IACD,4BAEC;IACD,uBAGC;IACD;;;OAGG;IACH,yBA8BC;IACD,aAaC;IACD;;;;;OAKG;IACH,wBAOC;IA+BD;;;;OAIG;IACH,eAmBC;IACD;;OAEG;IACH,yBAmEC;CACJ"}

package/dist/dist/{Schema-O1QLoXv6.d.ts → Schema-COTbavcm.d.ts}

@@ -11,6 +11,11 @@ declare class Schema {
      * Returns null if not found in cache
      */
     static getById(schemaFileId: any): any;
+    /**
+     * The cached schema with this file id or name, without taking a hold. For SDK code that reads
+     * the schema and doesn't hand it to a caller; callers that keep it use `create` or `find`.
+     */
+    static peek(schemaFileIdOrName: any): any;
     /**
      * Clear all cached Schema instances.
      * This is primarily useful for test cleanup.
@@ -21,9 +26,9 @@ declare class Schema {
      * Create or get schema instance by schemaFileId
      * Queries the database to find the schema name if not cached
      * @param schemaFileId - The schema file ID
-     * @returns Schema instance
+     * @returns Schema instance, with a hold taken (unless `hold: false`)
      */
-    static createById(schemaFileId: any): Promise<any>;
+    static createById(schemaFileId: any, options: any): Promise<any>;
     /**
      * Find schema instance by schemaFileId
      * Waits for the schema to be fully loaded (idle state) by default
@@ -39,6 +44,7 @@ declare class Schema {
      * Get instantiated Schema objects for all schemas (from database and files)
      * By default, returns only the latest version of each schema and excludes the internal Seed Protocol schema.
      * Uses loadAllSchemasFromDb() as the single source of truth, which intelligently merges database and file data.
+     * Takes no holds on the instances it returns: a caller that keeps one uses `Schema.create` or `Schema.find`.
      *
      * @param options - Configuration options
      * @param options.includeAllVersions - If true, returns all versions of each schema. Default: false
@@ -445,7 +451,7 @@ declare function deletePropertyFromModel(schemaName: any, modelName: any, proper
 declare var Schema$1: Readonly<{
     __proto__: null;
     Schema: typeof Schema;
-    schemaInstanceState: WeakMap<object, any>;
+    schemaInstanceState: ActorKeyedState;
 }>;
 /**
  * Delete a model from a schema
@@ -597,5 +603,6 @@ declare const schemaMachine: import("xstate").StateMachine<{}, import("xstate").
  * @throws Error if schema not found or updates are invalid
  */
 declare function updateModelProperties(schemaName: any, propertyUpdates: any, modelUpdates: any): Promise<any>;
+import { $ as ActorKeyedState } from './Item-BiMHgg-_.js';
 export { Schema as S, deletePropertyFromModel as a, Schema$1 as b, deleteModelFromSchema as d, renameModelProperty as r, schemaMachine as s, updateModelProperties as u };
-//# sourceMappingURL=Schema-O1QLoXv6.d.ts.map
+//# sourceMappingURL=Schema-COTbavcm.d.ts.map

package/dist/dist/Schema-COTbavcm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Schema-COTbavcm.d.ts","sourceRoot":"","sources":["../Schema-COTbavcm.js"],"names":[],"mappings":"AAihIA;IAiCI,kDAoPC;IACD;;;;OAIG;IACH,iEAaC;IACD;;;OAGG;IACH,uCAMC;IACD;;;OAGG;IACH,0CAGC;IACD;;;;OAIG;IACH,0BAwBC;IACD;;;;;OAKG;IACH,iEAgCC;IACD;;;;;OAKG;IACH;;;;qBAgBC;IACD;;;;;;;;;;OAUG;IACH,yCA+IC;IA01BD;;;;;OAKG;IACH,oCAkCC;IAn7CD,6BA+BC;IA3BG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAEE;IA4iBN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAEC;IACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAEC;IACD,0BAEC;IACD,sBAeC;IACD,wBAEC;IACD,cAEC;IACD;;;;OAIG;IACH,oBAmCC;IACD;;MAEC;IACD,oBAcC;IACD,4BAEC;IACD;;;OAGG;IACH,yBAEC;IACD,uBAGC;IACD;;;OAGG;IACH,yBA8BC;IACD;;;;OAIG;IACH,yCAoEC;IACD;;;;;;OAMG;IACH,+BAqLC;IACD;;;OAGG;IACH;;;;;;;;;;;;;;OAyCC;IACD;;;OAGG;IACH,uBAwBC;IACD;;;;;OAKG;IACH,0DAqXC;IA0CD,eAwCC;IACD;;;OAGG;IACH,yBAgCC;IACD,mFAqEC;IACD;;;OAGG;IACH,oCAgKC;CACJ;;;;;;;AAr2DD;;;;;;;;GAQG;AACH,0HA4EC;AA0xDD;;;;GAIG;AA//DH;;;;;;;GAOG;AACH,oGAmIC;AA5PD;;;;;;;;;GASG;AACH,gIAsGC;AAvlCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCA4jBG;AA2LH;;;;;;;GAOG;AACH,+GA6HC;qCAziH0Q,oBAAoB"}

package/dist/dist/{SchemaValidationService-BxCbfDaI.d.ts → SchemaValidationService-paOfbcwd.d.ts}

@@ -115,4 +115,4 @@ export class SchemaValidationService {
      */
     validateCustomRules(value: any, rules: any): any[];
 }
-//# sourceMappingURL=SchemaValidationService-BxCbfDaI.d.ts.map
+//# sourceMappingURL=SchemaValidationService-paOfbcwd.d.ts.map

package/dist/dist/{SchemaValidationService-BxCbfDaI.d.ts.map → SchemaValidationService-paOfbcwd.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"SchemaValidationService-BxCbfDaI.d.ts","sourceRoot":"","sources":["../SchemaValidationService-BxCbfDaI.js"],"names":[],"mappings":"AA8BA;;GAEG;AACH;IACI;;OAEG;IACH,kEAqBC;IACD;;OAEG;IACH,wDAyDC;IACD;;OAEG;IACH,uDAgBC;IACD;;OAEG;IACH,oDA8BC;IACD;;OAEG;IACH;;;;;;;;MA2HC;IACD;;;;;;OAMG;IACH,+FAsJC;IACD;;OAEG;IACH;;;;;;;;MA2GC;IACD;;OAEG;IACH;;;;;;;;MAiCC;IACD;;;OAGG;IACH;;;;;;;;MAcC;IACD;;OAEG;IACH;;;;;;;;MA4BC;IACD;;OAEG;IACH;;;;;;;;MA4CC;IACD;;OAEG;IACH,mXAsBC;IACD;;;;;OAKG;IACH,kEA0BC;IACD;;OAEG;IACH,mDAOC;CACJ"}
+{"version":3,"file":"SchemaValidationService-paOfbcwd.d.ts","sourceRoot":"","sources":["../SchemaValidationService-paOfbcwd.js"],"names":[],"mappings":"AA8BA;;GAEG;AACH;IACI;;OAEG;IACH,kEAqBC;IACD;;OAEG;IACH,wDAyDC;IACD;;OAEG;IACH,uDAgBC;IACD;;OAEG;IACH,oDA8BC;IACD;;OAEG;IACH;;;;;;;;MA2HC;IACD;;;;;;OAMG;IACH,+FAsJC;IACD;;OAEG;IACH;;;;;;;;MA2GC;IACD;;OAEG;IACH;;;;;;;;MAiCC;IACD;;;OAGG;IACH;;;;;;;;MAcC;IACD;;OAEG;IACH;;;;;;;;MA4BC;IACD;;OAEG;IACH;;;;;;;;MA4CC;IACD;;OAEG;IACH,mXAsBC;IACD;;;;;OAKG;IACH,kEA0BC;IACD;;OAEG;IACH,mDAOC;CACJ"}

package/dist/dist/{backfillMetadataPropertyIds-CzSbuucw.d.ts → backfillMetadataPropertyIds-BkpBahbz.d.ts}

@@ -4,4 +4,4 @@
  * Call after appDb is set (e.g. at end of prepareDb).
  */
 export function backfillMetadataPropertyIds(): Promise<number>;
-//# sourceMappingURL=backfillMetadataPropertyIds-CzSbuucw.d.ts.map
+//# sourceMappingURL=backfillMetadataPropertyIds-BkpBahbz.d.ts.map

package/dist/dist/backfillMetadataPropertyIds-BkpBahbz.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backfillMetadataPropertyIds-BkpBahbz.d.ts","sourceRoot":"","sources":["../backfillMetadataPropertyIds-BkpBahbz.js"],"names":[],"mappings":"AAmBA;;;;GAIG;AACH,+DA4CC"}

package/dist/dist/{configurePlatform-Bbpw_R4y.d.ts → configurePlatform-_XR45RnJ.d.ts}

@@ -27,4 +27,4 @@ declare var configurePlatform$1: Readonly<{
  */
 declare function configurePlatform(services: any): void;
 export { BasePathResolver as B, configurePlatform$1 as a, configurePlatform as c };
-//# sourceMappingURL=configurePlatform-Bbpw_R4y.d.ts.map
+//# sourceMappingURL=configurePlatform-_XR45RnJ.d.ts.map

package/dist/dist/configurePlatform-_XR45RnJ.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configurePlatform-_XR45RnJ.d.ts","sourceRoot":"","sources":["../configurePlatform-_XR45RnJ.js"],"names":[],"mappings":"AAiBA;IACI,kCAKC;IACD;;MAIC;IACD,0BAKC;IACD;;OAEG;IACH,0BAEC;IACD,qCAEC;IACD,4BAEC;IACD,gCAEC;IACD,8CAEC;IACD,2CAEC;IACD,4CAEC;CACJ;;;;AAeD;;;GAGG;AAfH;;GAEG;AACH,wDAOC"}

package/dist/dist/{detachRowsBeforeDelete-D1TyEMco.d.ts → detachRowsBeforeDelete-C1iapUFl.d.ts}

@@ -10,4 +10,4 @@ export function detachModelRows(db: any, modelIds: any): Promise<void>;
  * browser leaves rows pointing at deleted ids.
  */
 export function detachPropertyRows(db: any, propertyIds: any): Promise<void>;
-//# sourceMappingURL=detachRowsBeforeDelete-D1TyEMco.d.ts.map
+//# sourceMappingURL=detachRowsBeforeDelete-C1iapUFl.d.ts.map

package/dist/dist/detachRowsBeforeDelete-C1iapUFl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detachRowsBeforeDelete-C1iapUFl.d.ts","sourceRoot":"","sources":["../detachRowsBeforeDelete-C1iapUFl.js"],"names":[],"mappings":"AA8BA;;;GAGG;AACH,uEAWC;AA5BD;;;;;GAKG;AACH,6EAMC"}

package/dist/dist/{discardNewDraft-hiVaUVjV.d.ts → discardNewDraft-D4nrwp3T.d.ts}

@@ -5,4 +5,4 @@
  * File deletion is best-effort.
  */
 export function discardNewDraft(seedLocalId: any): Promise<void>;
-//# sourceMappingURL=discardNewDraft-hiVaUVjV.d.ts.map
+//# sourceMappingURL=discardNewDraft-D4nrwp3T.d.ts.map

package/dist/dist/discardNewDraft-D4nrwp3T.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discardNewDraft-D4nrwp3T.d.ts","sourceRoot":"","sources":["../discardNewDraft-D4nrwp3T.js"],"names":[],"mappings":"AAyBA;;;;;GAKG;AACH,iEA2CC"}

package/dist/dist/{eas-DOdj-EMK.d.ts → eas-BRVEGT97.d.ts}

@@ -9,4 +9,4 @@ export function getModelSchemasFromEas(): Promise<{
     }>;
 }[]>;
 export { PUBLISHED_BY_SCHEMA_DEF, PUBLISHED_BY_SCHEMA_NAME, decodePublishedByData, getCanonicalItemPropertiesFromEas, getEasSchemaUidBySchemaName, getItemPropertiesFromEas, getItemVersionsFromEas, getPublishedByFromEas, getSeedUidsBySchemaName, getSeedsBySchemaName, getSeedsFromSchemaUids, hashPublishedByBatch, verifyPublishedByBatch } from "@seedprotocol/eas";
-//# sourceMappingURL=eas-DOdj-EMK.d.ts.map
+//# sourceMappingURL=eas-BRVEGT97.d.ts.map

package/dist/dist/eas-BRVEGT97.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eas-BRVEGT97.d.ts","sourceRoot":"","sources":["../eas-BRVEGT97.js"],"names":[],"mappings":"AAkBA,qDAAqD;AACrD;;;;;kBAiD8u9F,CAAC;;;KAJ9u9F"}