@seedprotocol/sdk 0.7.7 → 0.7.8-next.1066.gac32194

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

@@ -1,51 +1,63 @@
+declare function getGetPublisherForNewSeeds(): any;
 /**
- * Release one reference to a cached entity instance. When none remain, remove it from the
- * caches, clean up its subscriptions and stop its service
+ * Throws OwnershipError if the item is not owned. Use before write operations
+ * (publish, save, destroy).
+ */
+declare function assertItemOwned(item: any): Promise<void>;
+/**
+ * Checks if the current user owns the item: its publisher is in the persisted owned addresses,
+ * or it's a local unsealed draft (no publisher, no real uid, no attestationRaw). Such a draft
+ * was made with no wallet connected and is editable until `claimUnpublishedDrafts`, which
+ * connecting a wallet calls, gives it that wallet as publisher.
  *
- * @param instance - Entity instance to unload
- * @param config - Unload configuration
+ * Does not include `getAdditionalSyncAddresses` (those are extra EAS indexers,
+ * not wallets the user controls).
  */
-declare function unloadEntity(instance: any, config: any): void;
-declare function getPublishExecutor(): any;
-declare function getRevokeExecutor(): any;
-declare var ClientManagerState: any;
+declare function isItemOwned(item: any): Promise<boolean>;
 /**
- * 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.
+ * Wait for an entity's state machine to reach 'idle' state
+ * @param entity - Entity instance with getService() method
+ * @param options - Configuration options
+ * @returns Promise that resolves when entity reaches idle, or rejects on error/timeout
  */
-declare const DEFAULT_READY_TIMEOUT_MS: 15000;
-/** @deprecated See UploadExecutor. */
-declare function getUploadExecutor(): any;
+declare function waitForEntityIdle(entity: any, options?: {}): Promise<void>;
+/** Sort comparator: live before revoked; then larger time first; on tie, larger localId (lexicographic) first. */
+declare function compareMetadataRowsLatestFirst(a: any, b: any): number;
 /**
- * Per-seed version aggregates plus the latest version row by (created_at DESC, local_id DESC) via
- * max(created_at) then max(local_id) tie-break.
- *
- * Revoked versions (`revoked_at` set) are never the latest version and don't count toward
- * `lastVersionPublishedAt`. `versionsCount` and `lastLocalUpdateAt` still cover every version row,
- * so a fully unpublished seed (every version revoked) keeps its row here, with null
- * `latestVersionUid` / `latestVersionLocalId` / `lastVersionPublishedAt`.
- *
- * For `publishedVersionUid` / `publishedVersionLocalId` on list rows, see `getItemsData`
- * (batched resolution aligned with `getLatestPublishedVersionRow`).
+ * EAS schema UID of a model's seeds: the in-memory cache, then `model_uids` (written from EAS by
+ * startup and sync), then EAS itself. The DB comes before EAS so creating items and saving
+ * images, files and Html bodies works offline. A failed EAS request (offline) counts as "no UID":
+ * the seed is created without one and publish looks it up again.
  */
-declare function getVersionData$1(): any;
+declare function getEasSchemaUidForModel(modelName: any): Promise<any>;
 /**
- * Local draft that has never been attested: no publisher, no real uid, no attestationRaw.
+ * Latest version row for the seed (by createdAt) whose uid is a real EAS attestation id.
+ * Skips legacy 'NULL' / ZERO_BYTES32 placeholders, non-bytes32 strings, and revoked versions
+ * (`revoked_at` set): after a full unpublish the seed has no published version.
  */
-declare function isLocalUnsealedDraft(row: any): boolean;
+declare function getLatestPublishedVersionRow(seedLocalId: any): Promise<{
+    uid: any;
+    localId: any;
+    attestationCreatedAt: any;
+} | null>;
 /**
- * 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.
+ * Parse List property values persisted as strings (JSON array or legacy comma-separated ids).
  */
-declare function isSeedRowOwned(row: any, ownedAddresses: any): boolean;
+declare function parseListPropertyValueFromStorage(raw: any): any;
+/** Splits `values` into chunks of at most `size` (one empty list gives no chunks). */
+declare function chunkValues(values: any, size?: number): any[];
 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 +71,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
@@ -72,7 +89,11 @@ declare class Item {
     static waitForItemInstanceReadyForRead(item: any, readyTimeout: any): Promise<void>;
     static itemCacheEntryLooksUnhydratedAfterIdle(instance: any, props: any): boolean;
     static create(props: any, options: any): Promise<any>;
-    /** Stops a just-created item and deletes what create wrote (see discardNewDraft). */
+    /**
+     * Stops a just-created item and deletes what create wrote: a `discard` outbox op (ADR 0019),
+     * applied after the item's other pending ops, hard-deletes the draft and the storage seeds its
+     * rows point at; their files go once it has applied.
+     */
     static discardCreatedItem(item: any, seedLocalId: any): Promise<void>;
     /**
      * Run each File/Image/Html/ItemStorage initial value through its ItemProperty save pipeline (sequentially, to
@@ -150,6 +171,11 @@ declare class Item {
             readonly error: {};
         };
     }, import("xstate").MetaObject>>;
+    /**
+     * The item's unresolved conflicts, one per property: local edits that were kept over a value
+     * sync wrote while they were pending (ADR 0019). Each property's is also on `property.conflict`.
+     */
+    conflicts: () => Promise<any[]>;
     getEditedProperties: () => Promise<any>;
     unpublish: () => Promise<void>;
     /**
@@ -193,13 +219,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.
+     */
+    _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.
      */
-    _definePropertyAccessor(propertyName: any): void;
+    _persistSeedUid(seedUid: any): void;
+    _createPropertyInstance(props: any): void;
     get serviceContext(): {};
     /**
      * Get snapshot context from the service
@@ -279,21 +311,17 @@ 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).
+ * 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 ownedPublisherSql(ownedAddresses: any): import("drizzle-orm").SQL<any>;
+declare function rowsPerInsert(table: any): number;
+declare function getGetAdditionalSyncAddresses(): any;
 /**
- * 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.
+ * 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 ownedSeedsSql(ownedAddresses: any): import("drizzle-orm").SQL<unknown> | undefined;
+declare function selectInBatches(values: any, query: any, size?: number): Promise<any[]>;
 /**
  * Canonical "latest metadata row first" ordering, the one readers use to pick a property's value
  * from its rows across versions:
@@ -310,16 +338,161 @@ 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[];
 /**
- * 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.
+ * True when a version row's attestation was revoked (`versions.revoked_at` set). 0 counts as
+ * "not revoked", like `seeds.revoked_at`.
  */
-declare class OwnershipError extends Error {
-    constructor(message?: string);
-}
+declare function isVersionRevoked(revokedAt: any): boolean;
+/** How long a deferred op waits before the drainer tries it again. */
+declare const OUTBOX_DEFER_MS: 50;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * Creates a reactive Proxy that intercepts property access and assignment
+ * to read from and write to an actor service's context.
+ *
+ * This enables automatic React re-renders when properties change, as the
+ * React hooks subscribe to the actor service which gets updated when properties
+ * are set via the proxy.
+ *
+ * @param config Configuration object
+ * @returns A proxied instance that behaves like the original but with reactive properties
+ *
+ * @note TypeScript's Proxy type doesn't automatically preserve method signatures,
+ * so we use Proxied<T> to ensure all methods and properties are recognized.
+ * 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;
+/**
+ * Generic find implementation for entities
+ *
+ * @param config - Find configuration with lookup methods
+ * @param params - Find parameters (id, name, or other entity-specific params)
+ * @param options - Find options (waitForReady, readyTimeout)
+ * @returns Entity instance if found, undefined otherwise
+ */
+declare function findEntity(config: any, params: any, options?: {}): 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;
+/**
+ * Run the service event sequence and stop the service:
+ * destroyStarted -> doDestroy -> (destroyError on failure) -> stop.
+ * A doDestroy failure is recorded on the service (destroyError) and rethrown, so destroy()
+ * rejects instead of resolving with the rows still in the DB.
+ * Event names must match what the entity machines expect.
+ */
+declare function runDestroyLifecycle(instance: any, config: any): Promise<void>;
+/**
+ * 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;
+declare var ClientManagerState: any;
+declare var MachineIds: any;
 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.";
+/**
+ * Writes a new item (ADR 0019): its seed, first version and a row per property go in one outbox op
+ * applied in one transaction, so a failure leaves nothing behind. ItemStorage initial values are
+ * staged first and moved into the item's files when the op applies.
+ */
+declare function createNewItem({ modelName, modelFileId, ...propertyData }: {
+    [x: string]: any;
+    modelName: any;
+    modelFileId: any;
+}): Promise<{
+    modelName: any;
+    seedLocalId: string;
+    versionLocalId: any;
+}>;
+/**
+ * Appends one op and waits until it settles: its applier's result once applied, or `superseded`
+ * when a newer op of its property replaced it. Rejects with OutboxOpFailedError when it fails.
+ */
+declare function appendOutboxOpAndWait(input: any): Promise<{
+    superseded: boolean;
+    result?: undefined;
+} | {
+    superseded: boolean;
+    result: 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 function getPublishExecutor(): any;
+declare function getRevokeExecutor(): any;
+/** @deprecated See UploadExecutor. */
+declare function getUploadExecutor(): any;
+/**
+ * Per-seed version aggregates plus the latest version row by (created_at DESC, local_id DESC) via
+ * max(created_at) then max(local_id) tie-break.
+ *
+ * Revoked versions (`revoked_at` set) are never the latest version and don't count toward
+ * `lastVersionPublishedAt`. `versionsCount` and `lastLocalUpdateAt` still cover every version row,
+ * so a fully unpublished seed (every version revoked) keeps its row here, with null
+ * `latestVersionUid` / `latestVersionLocalId` / `lastVersionPublishedAt`.
+ *
+ * For `publishedVersionUid` / `publishedVersionLocalId` on list rows, see `getItemsData`
+ * (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;
+/** 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).
+ */
+declare function ownedPublisherSql(ownedAddresses: any): import("drizzle-orm").SQL<any>;
+/**
+ * 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, {
@@ -406,27 +579,188 @@ 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.
+ * 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.
+ *
+ * `getService()` must return the actor before the first `set`.
  */
-declare function getInvariantSafePropertyDescriptor(target: any, prop: any, invent: any): TypedPropertyDescriptor<any> | {
-    enumerable: boolean;
-    configurable: boolean;
-    value: any;
-    writable: any;
-} | undefined;
+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;
+}
 /**
  * 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.
+ * Unsubscribe the entity's liveQueries and any extra subscription (e.g. Item/ItemProperty
+ * _subscription), and drop its instance state. 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;
+/** Resolve publisher from seed row: `publisher` column, else `attestationRaw.attester`. */
+declare function resolvePublisherFromSeedRow(row: any): any;
+/**
+ * The publisher a seed's version and property rows take: the seed's own (its `publisher`, else the
+ * attester of its stored attestation). Undefined for a draft that belongs to no wallet yet; those
+ * rows are then claimed together with their seed (claimUnpublishedDrafts).
+ */
+declare function getSeedPublisher(seedLocalId: any, db?: any): Promise<any>;
+/** Html, Image, File and Relation rows are stored as `<name>Id`; match either spelling. */
+declare function propertyNameVariants(name: any): any[];
+declare function createSeed({ type, seedUid, modelFileId }: {
+    type: any;
+    seedUid: any;
+    modelFileId: any;
+}, options?: {}): Promise<any>;
+declare function createMetadata(metadataValues: any, propertyRecordSchema: any, options: any): Promise<any>;
+declare function updateItemPropertyValue({ localId: localIdParam, propertyName, newValue, seedUid, seedLocalId, modelName, refSeedType, refResolvedValue, refResolvedDisplayValue, versionLocalId, versionUid, schemaUid, localStorageDir, dataType, refValueType, }: {
+    localId: any;
+    propertyName: any;
+    newValue: any;
+    seedUid: any;
+    seedLocalId: any;
+    modelName: any;
+    refSeedType: any;
+    refResolvedValue: any;
+    refResolvedDisplayValue: any;
+    versionLocalId: any;
+    versionUid: any;
+    schemaUid: any;
+    localStorageDir: any;
+    dataType: any;
+    refValueType: any;
+}, options?: {}): Promise<{
+    localId: any;
+    uid: any;
+    schemaUid: any;
+} | undefined>;
+declare var getPropertyData$1: Readonly<{
+    __proto__: null;
+    getPropertyData: ({ propertyName, seedLocalId, seedUid, modelName, }: {
+        propertyName: any;
+        seedLocalId: any;
+        seedUid: any;
+        modelName: any;
+    }) => Promise<any>;
+}>;
+declare var Item$1: Readonly<{
+    __proto__: null;
+    Item: typeof Item;
+}>;
+/**
+ * Resolves once the op is applied, or superseded by a newer op that applied; rejects with
+ * OutboxOpFailedError when it, or the op that superseded it, failed.
+ */
+declare function waitForOutboxOp(opId: any): Promise<any>;
+/** Appends one op; see appendOutboxOps. */
+declare function appendOutboxOp(input: any): Promise<any>;
+/** Attempts before a retryable error fails the op. */
+declare const OUTBOX_MAX_ATTEMPTS: 8;
+/** Applied and superseded ops are kept this long, then pruned. */
+declare const OUTBOX_PRUNE_AFTER_MS: number;
+/** Failed ops are kept longer, so a refused write can still be looked into. */
+declare const OUTBOX_PRUNE_FAILED_AFTER_MS: number;
+/** The status of each op, by id; ops not found are left out. */
+declare function getOutboxOps(opIds: any): Promise<any>;
+/** Waits before each retry of an op that failed with a retryable error; the last is reused. */
+declare const OUTBOX_RETRY_DELAYS_MS: number[];
+/**
+ * An op that can't apply yet for a reason that will pass without counting as a failure: an applier's
+ * `around` found a lock held. The drainer sets the op (and its property's queue) aside for
+ * OUTBOX_DEFER_MS and goes on with other ops; its attempts aren't counted.
+ */
+declare class OutboxOpDeferredError extends Error {
+    constructor(message: any);
+}
+/** Rejects `waitForOutboxOp` for an op that failed, or that a failed op superseded. */
+declare class OutboxOpFailedError extends Error {
+    constructor(opId: any, message: any, errorName?: null);
+    opId: any;
+    errorName: any;
+    code: string;
+}
+/** An op that can never apply (a broken rule, an item the client doesn't own). Not retried. */
+declare class OutboxOpRejectedError extends Error {
+    constructor(message: any, options: any);
+}
+/** A failure worth retrying (a file the browser had locked, say). Other errors fail the op at once. */
+declare class OutboxOpRetryableError extends Error {
+    constructor(message: any, options: any);
+}
+/**
+ * Appends one op, or several that apply together (they share a new group id unless they carry
+ * one), and tells the leader to drain. Returns the op ids in order.
+ */
+declare function appendOutboxOps(inputs: any): Promise<any>;
+/**
+ * Applies every pending op that is due, in order. Exported for tests and for code that must see
+ * the outbox applied before it continues; normally the leader drains on its own.
+ */
+declare function drainOutbox(): Promise<void>;
+/** What an applied op's applier returned, decoded. */
+declare function outboxOpResult(op: any): any;
+/**
+ * The value an item property will have once its pending `set` ops apply, in its stored string form.
+ * Undefined when its newest pending value op is not a `set`, or it has none.
+ */
+declare function getPendingSetValue(seedLocalId: any, propertyName: any): Promise<any>;
+/** An op's stored value, decoded. */
+declare function outboxOpValue(op: any): any;
+/**
+ * Deletes settled ops older than their retention: applied and superseded ops after
+ * OUTBOX_PRUNE_AFTER_MS, failed ones after OUTBOX_PRUNE_FAILED_AFTER_MS. An applied op with an
+ * unresolved conflict stays until the conflict is resolved. Pending ops are never pruned. The
+ * leader runs it after a drain, at most hourly. Returns how many ops it deleted.
+ */
+declare function pruneOutbox(now?: number): Promise<any>;
+/** Registers the applier for one op kind; returns a function that removes it. */
+declare function registerOutboxApplier(kind: any, applier: any): () => void;
+/**
+ * Starts draining in this tab once it is the leader, resuming ops left pending (a reload, a closed
+ * leader tab), and listens for other tabs' nudges and settled ops. Safe to call more than once.
+ */
+declare function startOutbox(): void;
+/** 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>;
+/**
+ * Assemble flat ItemData for Item / liveQuery / draft-head authoring.
+ *
+ * For **published chain JSON** (Seed → latest attested Version → properties),
+ * prefer `getPublishedSeedRecord` from `@seedprotocol/sdk` or
+ * `getSeed` / `queryBySchema` from `@seedprotocol/query`. This function remains
+ * the correct path for local-head / draft-wins property selection used by Item.
+ */
+declare function getItemData({ modelName, seedLocalId, seedUid, }: {
+    modelName: any;
+    seedLocalId: any;
+    seedUid: any;
+}): Promise<any>;
+/**
+ * Resolves once every op pending when it was called has settled (applied, superseded or failed),
+ * so a reader of `metadata` sees every edit made before. Publish waits on this before it reads.
+ */
+declare function waitForPendingOutboxOps(): Promise<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 +771,39 @@ 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;
+    /**
+     * Stops an item's cached properties that nobody holds. Internal lookups cache a property without
+     * a hold for the item to take; one that finished after the item stopped (a liveQuery handler's
+     * find, say) never got that hold and would otherwise keep running. Called when the item stops.
+     */
+    static unloadUnheldForItem(seedIds: any): void;
     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;
@@ -659,21 +1011,46 @@ declare class ItemProperty {
     /** Validation errors from last failed save (enum, pattern, minLength, maxLength). Cleared when the next save starts. */
     get saveValidationErrors(): any;
     get alias(): any;
+    /**
+     * The unresolved conflict between this property's last local edit and a value sync wrote while
+     * the edit was pending (ADR 0019): the local edit was kept, and `remoteValue` is what sync wrote.
+     * Null when there is none. Cleared by the next edit or `resolveConflict`.
+     */
+    get conflict(): any;
+    /**
+     * Settles `conflict`. `'local'` keeps the local edit. `'remote'` drops the local draft, so the
+     * synced value shows again (and publish has nothing to send for this property).
+     */
+    resolveConflict(choice: any): Promise<void>;
     set value(value: any);
     get value(): any;
     /**
      * Shows `value` at once and saves it; `await property.save()` to wait for the result. Unlike
      * assigning `property.value`, it saves even when `value` is already in context.
      *
-     * @param options.before - The values to restore if the save is refused or fails. Defaults to the
-     *   current context; pass it when you already put `value` into context (a debounced input, say),
-     *   so a refusal still rolls back to what was there before.
+     * @param options.before - The values to restore if the save is refused or fails. Defaults to what
+     *   showed before the first `showValue` since the last save, else the current context.
      */
     setValue(value: any, options?: {}): void;
+    _unsavedBefore: {
+        propertyValue: any;
+        renderValue: any;
+    } | undefined;
     _pendingSchemaSave: Promise<boolean> | undefined;
+    /**
+     * Shows `value` without saving it, for input that saves later (a debounced text field). The next
+     * `setValue` or assignment saves, and if that save is refused or fails, the property goes back to
+     * what showed before the first `showValue`.
+     */
+    showValue(value: any): void;
     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
@@ -681,211 +1058,24 @@ declare class ItemProperty {
      * Throws OwnershipError if none of the client's addresses own the item.
      */
     destroy(): Promise<void>;
+    _destroyRows(context: any): Promise<void>;
 }
 declare namespace ItemProperty {
     let instanceCache_1: Map<any, any>;
     export { instanceCache_1 as instanceCache };
 }
-declare var ClientManagerEvents: any;
-/**
- * Runs `fn` with a fresh read of metadata row `localId`, holding the lock of the file that row's
- * content goes to. `fileOf` names that file (absolute path) for a row, or returns undefined when
- * there is nothing to write (then `fn` isn't called and the result is undefined).
- *
- * The file depends on the row, so the row is read once to pick the lock and again once it is held;
- * if the row now points at another file (another writer changed it meanwhile), the lock is
- * released and taken again for that file.
- */
-declare function withLockedItemStorageRow(localId: any, fileOf: any, fn: any): Promise<any>;
-/** Absolute path of the file {@link writeItemStorageFile} writes for `target`. */
-declare function getItemStorageFilePath(target: any): string;
-/**
- * Write an ItemStorage property's content to its local file, where saveItemStorage, reads, publish
- * (resolveItemStorageChildFile) and download all look for it. Returns what the metadata row records:
- * `refResolvedValue` (the file name) and `localStorageDir` (with a leading slash).
- *
- * Callers that also update the file's metadata row hold {@link withItemStorageFileLock} around
- * both, so another writer of the same file can't land in between.
- */
-declare function writeItemStorageFile(target: any, content: any): Promise<{
-    fileName: any;
-    filePath: string;
-    localStorageDir: any;
-}>;
-/** Resolve publisher from seed row: `publisher` column, else `attestationRaw.attester`. */
-declare function resolvePublisherFromSeedRow(row: any): any;
-declare var getPropertyData$1: Readonly<{
-    __proto__: null;
-    getPropertyData: ({ propertyName, seedLocalId, seedUid, modelName, }: {
-        propertyName: any;
-        seedLocalId: any;
-        seedUid: any;
-        modelName: any;
-    }) => Promise<any>;
-}>;
-declare var Item$1: Readonly<{
-    __proto__: null;
-    Item: typeof Item;
-}>;
 /** Thrown by ItemProperty.save() when the value failed validation (enum, pattern, minLength, maxLength). */
 declare class ItemPropertySaveValidationError extends Error {
     constructor(message: any, validationErrors: any);
     validationErrors: any;
 }
 /**
- * Throws OwnershipError if the item is not owned. Use before write operations
- * (publish, save, destroy).
- */
-declare function assertItemOwned(item: any): Promise<void>;
-/**
- * Wait for an entity's state machine to reach 'idle' state
- * @param entity - Entity instance with getService() method
- * @param options - Configuration options
- * @returns Promise that resolves when entity reaches idle, or rejects on error/timeout
- */
-declare function waitForEntityIdle(entity: any, options?: {}): Promise<void>;
-/** Sort comparator: live before revoked; then larger time first; on tie, larger localId (lexicographic) first. */
-declare function compareMetadataRowsLatestFirst(a: any, b: any): number;
-/**
- * EAS schema UID of a model's seeds: the in-memory cache, then `model_uids` (written from EAS by
- * startup and sync), then EAS itself. The DB comes before EAS so creating items and saving
- * images, files and Html bodies works offline. A failed EAS request (offline) counts as "no UID":
- * the seed is created without one and publish looks it up again.
- */
-declare function getEasSchemaUidForModel(modelName: any): Promise<any>;
-/**
- * Assemble flat ItemData for Item / liveQuery / draft-head authoring.
- *
- * For **published chain JSON** (Seed → latest attested Version → properties),
- * prefer `getPublishedSeedRecord` from `@seedprotocol/sdk` or
- * `getSeed` / `queryBySchema` from `@seedprotocol/query`. This function remains
- * the correct path for local-head / draft-wins property selection used by Item.
- */
-declare function getItemData({ modelName, seedLocalId, seedUid, }: {
-    modelName: any;
-    seedLocalId: any;
-    seedUid: any;
-}): Promise<any>;
-/**
- * Latest version row for the seed (by createdAt) whose uid is a real EAS attestation id.
- * Skips legacy 'NULL' / ZERO_BYTES32 placeholders, non-bytes32 strings, and revoked versions
- * (`revoked_at` set): after a full unpublish the seed has no published version.
- */
-declare function getLatestPublishedVersionRow(seedLocalId: any): Promise<{
-    uid: any;
-    localId: any;
-    attestationCreatedAt: any;
-} | null>;
-/**
- * Checks if the current user owns the item: its publisher is in the persisted owned addresses,
- * or it's a local unsealed draft (no publisher, no real uid, no attestationRaw). Such a draft
- * was made with no wallet connected and is editable until `claimUnpublishedDrafts`, which
- * connecting a wallet calls, gives it that wallet as publisher.
- *
- * Does not include `getAdditionalSyncAddresses` (those are extra EAS indexers,
- * not wallets the user controls).
- */
-declare function isItemOwned(item: any): Promise<boolean>;
-/** Splits `values` into chunks of at most `size` (one empty list gives no chunks). */
-declare function chunkValues(values: any, size?: number): any[];
-declare function getGetAdditionalSyncAddresses(): any;
-/**
- * True when a version row's attestation was revoked (`versions.revoked_at` set). 0 counts as
- * "not revoked", like `seeds.revoked_at`.
- */
-declare function isVersionRevoked(revokedAt: any): boolean;
-/**
- * Creates a reactive Proxy that intercepts property access and assignment
- * to read from and write to an actor service's context.
- *
- * This enables automatic React re-renders when properties change, as the
- * React hooks subscribe to the actor service which gets updated when properties
- * are set via the proxy.
- *
- * @param config Configuration object
- * @returns A proxied instance that behaves like the original but with reactive properties
- *
- * @note TypeScript's Proxy type doesn't automatically preserve method signatures,
- * so we use Proxied<T> to ensure all methods and properties are recognized.
- * The Proxy implementation preserves all methods via Reflect.get, so this is safe.
- */
-declare function createReactiveProxy(config: any): any;
-/**
- * Generic find implementation for entities
- *
- * @param config - Find configuration with lookup methods
- * @param params - Find parameters (id, name, or other entity-specific params)
- * @param options - Find options (waitForReady, readyTimeout)
- * @returns Entity instance if found, undefined otherwise
- */
-declare function findEntity(config: any, params: any, options?: {}): 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.
- * A doDestroy failure is recorded on the service (destroyError) and rethrown, so destroy()
- * rejects instead of resolving with the rows still in the DB.
- * 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;
-declare var MachineIds: any;
-declare function createNewItem({ modelName, modelFileId, ...propertyData }: {
-    [x: string]: any;
-    modelName: any;
-    modelFileId: any;
-}): Promise<{
-    modelName: any;
-    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;
-    easDataType: any;
-}): Promise<{
-    __typename?: "Schema";
-    id: string;
-    schema: string;
-    schemaNames: Array<{
-        __typename?: "SchemaName";
-        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`.
+ * 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.
  */
-declare function getMetadataLatest({ seedLocalId, seedUid }: {
-    seedLocalId: any;
-    seedUid: any;
-}): any;
+declare class OwnershipError extends Error {
+    constructor(message?: string);
+}
 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 { getGetPublisherForNewSeeds as $, assertItemOwned as A, isItemOwned as B, waitForEntityIdle as C, compareMetadataRowsLatestFirst as D, getEasSchemaUidForModel as E, getLatestPublishedVersionRow as F, parseListPropertyValueFromStorage as G, chunkValues as H, Item as I, rowsPerInsert as J, getGetAdditionalSyncAddresses as K, selectInBatches as L, METADATA_LATEST_FIRST_ORDER_SQL as M, isVersionRevoked as N, OUTBOX_DEFER_MS as O, isActorStopped as P, DEFAULT_READY_TIMEOUT_MS as Q, createReactiveProxy as R, sameEntity as S, findEntity as T, forceRemoveFromCaches as U, runDestroyLifecycle as V, isPublishedMetadataRow as W, ClientManagerState as X, MachineIds as Y, PUBLISH_NOT_CONFIGURED_MESSAGE as Z, createNewItem as _, appendOutboxOpAndWait as a, getMetadataLatest as a0, getPublishExecutor as a1, getRevokeExecutor as a2, getUploadExecutor as a3, getVersionData$1 as a4, isLocalUnsealedDraft as a5, isSeedRowOwned as a6, localUnsealedDraftSql as a7, ownedPublisherSql as a8, ownedSeedsSql as a9, pickLatestMetadataRowPerProperty as aa, placeholderUidSql as ab, propertyMachine as ac, publisherInAddressListSql as ad, publisherIsInOwnedSet as ae, setAdditionalSyncAddresses as af, setGetPublisherForNewSeeds as ag, setPublishExecutor as ah, setRevokeExecutor as ai, setUploadExecutor as aj, ActorKeyedState as ak, clearDestroySubscriptions as al, unloadEntity as am, ClientManagerEvents as an, resolvePublisherFromSeedRow as ao, getSeedPublisher as ap, propertyNameVariants as aq, createSeed as ar, createMetadata as as, updateItemPropertyValue as at, getPropertyData$1 as au, Item$1 as av, waitForOutboxOp as b, appendOutboxOp as c, OUTBOX_MAX_ATTEMPTS as d, OUTBOX_PRUNE_AFTER_MS as e, OUTBOX_PRUNE_FAILED_AFTER_MS as f, getOutboxOps as g, OUTBOX_RETRY_DELAYS_MS as h, OutboxOpDeferredError as i, OutboxOpFailedError as j, OutboxOpRejectedError as k, OutboxOpRetryableError as l, appendOutboxOps as m, drainOutbox as n, outboxOpResult as o, getPendingSetValue as p, outboxOpValue as q, pruneOutbox as r, registerOutboxApplier as s, startOutbox as t, writeInBatches as u, getItemData as v, waitForPendingOutboxOps as w, ItemProperty as x, ItemPropertySaveValidationError as y, OwnershipError as z };
+//# sourceMappingURL=Item-DZfNz7xl.d.ts.map