mindoodb 0.0.44 → 0.0.46

package/dist/core/copy/entryRewrite.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Pure entry-rewriting helpers shared by the graft and replay strategies.
+ *
+ * @internal
+ * @module
+ */
+import type { StoreEntry, StoreEntryMetadata, StoreEntryType } from "../types";
+/**
+ * The entry types that make up a document's revision graph. `doc_snapshot` is
+ * included deliberately: after a dense sync it can be the only entry a peer
+ * holds for a document, so skipping it would silently drop content.
+ */
+export declare const DOCUMENT_DAG_ENTRY_TYPES: ReadonlySet<StoreEntryType>;
+/** True when the entry is part of the document revision graph. */
+export declare function isDocumentDagEntry(entry: StoreEntryMetadata): boolean;
+/**
+ * Re-point an entry id from one document to another.
+ *
+ * Every entry id — document (`<docId>_d_<depsFingerprint>_<automergeHash>`) and
+ * attachment chunk (`<docId>_a_<fileUuid7>_<chunkUuid>`) alike — begins with the
+ * document id followed by `_`, so re-homing an entry is a prefix swap.
+ *
+ * This is exact rather than a shortcut, and it is what makes a replay cheap:
+ * the deps fingerprint is `SHA-256` over the sorted *Automerge* dependency
+ * hashes, which a copy never changes, and the Automerge hash is a property of
+ * the change bytes, which a copy reuses verbatim. So the re-derived id is
+ * identical to what `generateDocEntryId()` would return under the new document
+ * id — without decrypting or decoding anything — and it is deterministic, which
+ * is what lets an interrupted copy resume by simply running again.
+ *
+ * Ids that do not carry the source prefix (a dependency on a foreign entry)
+ * are returned unchanged.
+ */
+export declare function remapEntryId(entryId: string, sourceDocId: string, targetDocId: string): string;
+/**
+ * Remove the server's witness receipt from a copied entry.
+ *
+ * The receipt signature binds the database id (see `crypto/WitnessReceipt.ts`),
+ * so carrying it into a different database would fail verification and
+ * quarantine the entry as `invalid_witness_receipt`. Stripped entries are
+ * provisional until the target database is pushed and re-witnessed.
+ *
+ * `receiptOrder` goes too: it is a per-store sequence the receiving store
+ * assigns, meaningless in another one.
+ */
+export declare function stripWitnessReceipt<T extends StoreEntryMetadata>(entry: T): T;
+/** Sum the encrypted payload sizes of a batch, for progress and result totals. */
+export declare function sumEncryptedSize(entries: StoreEntry[]): number;
+//# sourceMappingURL=entryRewrite.d.ts.map

package/dist/core/copy/entryRewrite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entryRewrite.d.ts","sourceRoot":"","sources":["../../../src/core/copy/entryRewrite.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/E;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,EAAE,WAAW,CAAC,cAAc,CAM/D,CAAC;AAEH,kEAAkE;AAClE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAErE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,GAClB,MAAM,CAIR;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,kBAAkB,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAS7E;AAED,kFAAkF;AAClF,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,MAAM,CAE9D"}

package/dist/core/copy/entryRewrite.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * Pure entry-rewriting helpers shared by the graft and replay strategies.
+ *
+ * @internal
+ * @module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DOCUMENT_DAG_ENTRY_TYPES = void 0;
+exports.isDocumentDagEntry = isDocumentDagEntry;
+exports.remapEntryId = remapEntryId;
+exports.stripWitnessReceipt = stripWitnessReceipt;
+exports.sumEncryptedSize = sumEncryptedSize;
+/**
+ * The entry types that make up a document's revision graph. `doc_snapshot` is
+ * included deliberately: after a dense sync it can be the only entry a peer
+ * holds for a document, so skipping it would silently drop content.
+ */
+exports.DOCUMENT_DAG_ENTRY_TYPES = new Set([
+    "doc_create",
+    "doc_change",
+    "doc_delete",
+    "doc_undelete",
+    "doc_snapshot",
+]);
+/** True when the entry is part of the document revision graph. */
+function isDocumentDagEntry(entry) {
+    return exports.DOCUMENT_DAG_ENTRY_TYPES.has(entry.entryType);
+}
+/**
+ * Re-point an entry id from one document to another.
+ *
+ * Every entry id — document (`<docId>_d_<depsFingerprint>_<automergeHash>`) and
+ * attachment chunk (`<docId>_a_<fileUuid7>_<chunkUuid>`) alike — begins with the
+ * document id followed by `_`, so re-homing an entry is a prefix swap.
+ *
+ * This is exact rather than a shortcut, and it is what makes a replay cheap:
+ * the deps fingerprint is `SHA-256` over the sorted *Automerge* dependency
+ * hashes, which a copy never changes, and the Automerge hash is a property of
+ * the change bytes, which a copy reuses verbatim. So the re-derived id is
+ * identical to what `generateDocEntryId()` would return under the new document
+ * id — without decrypting or decoding anything — and it is deterministic, which
+ * is what lets an interrupted copy resume by simply running again.
+ *
+ * Ids that do not carry the source prefix (a dependency on a foreign entry)
+ * are returned unchanged.
+ */
+function remapEntryId(entryId, sourceDocId, targetDocId) {
+    if (sourceDocId === targetDocId)
+        return entryId;
+    if (!entryId.startsWith(`${sourceDocId}_`))
+        return entryId;
+    return `${targetDocId}${entryId.slice(sourceDocId.length)}`;
+}
+/**
+ * Remove the server's witness receipt from a copied entry.
+ *
+ * The receipt signature binds the database id (see `crypto/WitnessReceipt.ts`),
+ * so carrying it into a different database would fail verification and
+ * quarantine the entry as `invalid_witness_receipt`. Stripped entries are
+ * provisional until the target database is pushed and re-witnessed.
+ *
+ * `receiptOrder` goes too: it is a per-store sequence the receiving store
+ * assigns, meaningless in another one.
+ */
+function stripWitnessReceipt(entry) {
+    const { receivedAt: _receivedAt, receivedByPublicKey: _receivedByPublicKey, receivedDateSignature: _receivedDateSignature, receiptOrder: _receiptOrder, ...rest } = entry;
+    return rest;
+}
+/** Sum the encrypted payload sizes of a batch, for progress and result totals. */
+function sumEncryptedSize(entries) {
+    return entries.reduce((total, entry) => total + entry.encryptedSize, 0);
+}
+//# sourceMappingURL=entryRewrite.js.map

package/dist/core/copy/entryRewrite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entryRewrite.js","sourceRoot":"","sources":["../../../src/core/copy/entryRewrite.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;AAkBH,gDAEC;AAoBD,oCAQC;AAaD,kDASC;AAGD,4CAEC;AAvED;;;;GAIG;AACU,QAAA,wBAAwB,GAAgC,IAAI,GAAG,CAAiB;IAC3F,YAAY;IACZ,YAAY;IACZ,YAAY;IACZ,cAAc;IACd,cAAc;CACf,CAAC,CAAC;AAEH,kEAAkE;AAClE,SAAgB,kBAAkB,CAAC,KAAyB;IAC1D,OAAO,gCAAwB,CAAC,GAAG,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;AACvD,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAgB,YAAY,CAC1B,OAAe,EACf,WAAmB,EACnB,WAAmB;IAEnB,IAAI,WAAW,KAAK,WAAW;QAAE,OAAO,OAAO,CAAC;IAChD,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,WAAW,GAAG,CAAC;QAAE,OAAO,OAAO,CAAC;IAC3D,OAAO,GAAG,WAAW,GAAG,OAAO,CAAC,KAAK,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE,CAAC;AAC9D,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,mBAAmB,CAA+B,KAAQ;IACxE,MAAM,EACJ,UAAU,EAAE,WAAW,EACvB,mBAAmB,EAAE,oBAAoB,EACzC,qBAAqB,EAAE,sBAAsB,EAC7C,YAAY,EAAE,aAAa,EAC3B,GAAG,IAAI,EACR,GAAG,KAAK,CAAC;IACV,OAAO,IAAS,CAAC;AACnB,CAAC;AAED,kFAAkF;AAClF,SAAgB,gBAAgB,CAAC,OAAqB;IACpD,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,GAAG,KAAK,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC;AAC1E,CAAC"}

package/dist/core/copy/feasibility.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Pure strategy resolution for document copies.
+ *
+ * Everything here is a side-effect-free function of a {@link CopyContext} plus
+ * the caller's {@link CopyDocumentOptions}, which keeps the "can I do this, and
+ * what would it cost me" question answerable without touching a store, and
+ * keeps the rules unit-testable in isolation from the copy engine.
+ *
+ * @module
+ */
+import type { CopyDocumentOptions, CopyFeasibility } from "./types";
+/** The tenant directory database id. Never a valid copy source or target. */
+export declare const DIRECTORY_DB_ID = "directory";
+/**
+ * Everything the resolver needs to know about the source and target, gathered
+ * by the copy engine before any work starts.
+ *
+ * @internal
+ */
+export interface CopyContext {
+    /** Tenant owning the source database. */
+    sourceTenantId: string;
+    /** Tenant owning the target database. */
+    targetTenantId: string;
+    /** Source database (store) id. */
+    sourceDbId: string;
+    /** Target database (store) id. */
+    targetDbId: string;
+    /** The document id being read from the source. */
+    sourceDocId: string;
+    /** The document id that will be written in the target, already resolved. */
+    targetDocId: string;
+    /** The `decryptionKeyId` the source document's entries currently use. */
+    sourceDecryptionKeyId: string;
+    /** The `decryptionKeyId` the copy will be written under, already resolved. */
+    targetDecryptionKeyId: string;
+    /** True when source and target document entries live in the same store. */
+    sameStore: boolean;
+    /** True when the target store already holds an entry for {@link targetDocId}. */
+    targetHasDocId: boolean;
+}
+/**
+ * Resolve the effective target `decryptionKeyId` for a copy.
+ *
+ * Within one tenant the source document's own key is kept, so a copy stays
+ * readable by exactly the same people and — crucially — stays eligible for
+ * authorship preservation. Across tenants the source key id is meaningless
+ * (key ids resolve tenant-scoped), so the copy falls back to the target
+ * tenant's `"default"` key.
+ */
+export declare function resolveTargetDecryptionKeyId(requested: string | undefined, sourceDecryptionKeyId: string, sameTenant: boolean): string;
+/**
+ * Decide what a copy would do, and whether it can run at all.
+ *
+ * The rules, in order:
+ *
+ * 1. Neither side may be the tenant directory database.
+ * 2. `flatten` mode always resolves to the flatten strategy and never preserves
+ *    authorship (there is no original entry left to preserve).
+ * 3. `history` mode preserves authorship only in the exact configuration where
+ *    the original `metadataSignature` remains valid: same tenant, same document
+ *    id, same key, different database. Anything else re-authors.
+ * 4. Asking for `authorship: "preserve"` outside that configuration is refused
+ *    rather than silently downgraded, because a caller who asked for it is
+ *    relying on the signatures being real.
+ */
+export declare function resolveCopyFeasibility(context: CopyContext, options?: CopyDocumentOptions): CopyFeasibility;
+/**
+ * Turn an unusable {@link CopyFeasibility} into the error thrown by
+ * `copyDocumentTo` / `copyDocumentsTo`.
+ */
+export declare function copyFeasibilityError(feasibility: CopyFeasibility): Error;
+//# sourceMappingURL=feasibility.d.ts.map

package/dist/core/copy/feasibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feasibility.d.ts","sourceRoot":"","sources":["../../../src/core/copy/feasibility.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EACV,mBAAmB,EACnB,eAAe,EAIhB,MAAM,SAAS,CAAC;AAEjB,6EAA6E;AAC7E,eAAO,MAAM,eAAe,cAAc,CAAC;AAE3C;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,yCAAyC;IACzC,cAAc,EAAE,MAAM,CAAC;IACvB,yCAAyC;IACzC,cAAc,EAAE,MAAM,CAAC;IACvB,kCAAkC;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,kCAAkC;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,kDAAkD;IAClD,WAAW,EAAE,MAAM,CAAC;IACpB,4EAA4E;IAC5E,WAAW,EAAE,MAAM,CAAC;IACpB,yEAAyE;IACzE,qBAAqB,EAAE,MAAM,CAAC;IAC9B,8EAA8E;IAC9E,qBAAqB,EAAE,MAAM,CAAC;IAC9B,2EAA2E;IAC3E,SAAS,EAAE,OAAO,CAAC;IACnB,iFAAiF;IACjF,cAAc,EAAE,OAAO,CAAC;CACzB;AAED;;;;;;;;GAQG;AACH,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,qBAAqB,EAAE,MAAM,EAC7B,UAAU,EAAE,OAAO,GAClB,MAAM,CAGR;AAUD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,WAAW,EACpB,OAAO,GAAE,mBAAwB,GAChC,eAAe,CAgJjB;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,eAAe,GAAG,KAAK,CAKxE"}

package/dist/core/copy/feasibility.js

@@ -0,0 +1,169 @@
+"use strict";
+/**
+ * Pure strategy resolution for document copies.
+ *
+ * Everything here is a side-effect-free function of a {@link CopyContext} plus
+ * the caller's {@link CopyDocumentOptions}, which keeps the "can I do this, and
+ * what would it cost me" question answerable without touching a store, and
+ * keeps the rules unit-testable in isolation from the copy engine.
+ *
+ * @module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DIRECTORY_DB_ID = void 0;
+exports.resolveTargetDecryptionKeyId = resolveTargetDecryptionKeyId;
+exports.resolveCopyFeasibility = resolveCopyFeasibility;
+exports.copyFeasibilityError = copyFeasibilityError;
+/** The tenant directory database id. Never a valid copy source or target. */
+exports.DIRECTORY_DB_ID = "directory";
+/**
+ * Resolve the effective target `decryptionKeyId` for a copy.
+ *
+ * Within one tenant the source document's own key is kept, so a copy stays
+ * readable by exactly the same people and — crucially — stays eligible for
+ * authorship preservation. Across tenants the source key id is meaningless
+ * (key ids resolve tenant-scoped), so the copy falls back to the target
+ * tenant's `"default"` key.
+ */
+function resolveTargetDecryptionKeyId(requested, sourceDecryptionKeyId, sameTenant) {
+    if (requested)
+        return requested;
+    return sameTenant ? sourceDecryptionKeyId : "default";
+}
+/** Build a reason record with a stable code and a human-readable message. */
+function reason(code, message) {
+    return { code, message };
+}
+/**
+ * Decide what a copy would do, and whether it can run at all.
+ *
+ * The rules, in order:
+ *
+ * 1. Neither side may be the tenant directory database.
+ * 2. `flatten` mode always resolves to the flatten strategy and never preserves
+ *    authorship (there is no original entry left to preserve).
+ * 3. `history` mode preserves authorship only in the exact configuration where
+ *    the original `metadataSignature` remains valid: same tenant, same document
+ *    id, same key, different database. Anything else re-authors.
+ * 4. Asking for `authorship: "preserve"` outside that configuration is refused
+ *    rather than silently downgraded, because a caller who asked for it is
+ *    relying on the signatures being real.
+ */
+function resolveCopyFeasibility(context, options = {}) {
+    const mode = options.mode ?? "flatten";
+    const authorship = options.authorship ?? "reauthor";
+    const wantsPreserve = authorship === "preserve";
+    const sameTenant = context.sourceTenantId === context.targetTenantId;
+    const sameDocId = context.sourceDocId === context.targetDocId;
+    const sameKey = context.sourceDecryptionKeyId === context.targetDecryptionKeyId;
+    // Key ids resolve per tenant, so an identical id across tenants still names a
+    // different key and still forces re-encryption.
+    const requiresReEncryption = !sameTenant || !sameKey;
+    const reasons = [];
+    const isDirectory = (dbId) => dbId === exports.DIRECTORY_DB_ID;
+    if (isDirectory(context.sourceDbId) || isDirectory(context.targetDbId)) {
+        reasons.push(reason("directory_database", "The tenant directory database cannot be used as a copy source or target."));
+        return {
+            allowed: false,
+            strategy: mode === "flatten" ? "flatten" : "replay",
+            authorshipPreserved: false,
+            willMergeIntoExisting: false,
+            sameStore: context.sameStore,
+            requiresReEncryption,
+            reasons,
+        };
+    }
+    if (context.sameStore && sameDocId) {
+        reasons.push(reason("same_database_same_doc_id", `Source and target are the same database (${context.sourceDbId}) and the ` +
+            `target document id is unchanged (${context.targetDocId}), so there is ` +
+            "nothing to copy. Use targetDocId 'new' to duplicate in place."));
+        return {
+            allowed: false,
+            strategy: mode === "flatten" ? "flatten" : "replay",
+            authorshipPreserved: false,
+            willMergeIntoExisting: true,
+            sameStore: true,
+            requiresReEncryption,
+            reasons,
+        };
+    }
+    if (mode === "flatten") {
+        if (wantsPreserve) {
+            reasons.push(reason("flatten_mode", "Flatten mode writes a single new change, so there is no original " +
+                "entry whose authorship could be preserved. Use mode 'history' with " +
+                "authorship 'preserve'."));
+            return {
+                allowed: false,
+                strategy: "flatten",
+                authorshipPreserved: false,
+                willMergeIntoExisting: context.targetHasDocId,
+                sameStore: context.sameStore,
+                requiresReEncryption,
+                reasons,
+            };
+        }
+        return {
+            allowed: true,
+            strategy: "flatten",
+            authorshipPreserved: false,
+            willMergeIntoExisting: context.targetHasDocId,
+            sameStore: context.sameStore,
+            requiresReEncryption,
+            reasons,
+        };
+    }
+    // mode === "history": collect every condition that blocks preservation.
+    if (!sameTenant) {
+        reasons.push(reason("different_tenant", `Source tenant '${context.sourceTenantId}' differs from target tenant ` +
+            `'${context.targetTenantId}'. The payload must be re-encrypted under the ` +
+            "target tenant key, and the source authors' keys are not in the target " +
+            "tenant's directory, so their signatures could not be verified there."));
+    }
+    if (!sameDocId) {
+        reasons.push(reason("different_doc_id", `The copy lands under document id '${context.targetDocId}' instead of ` +
+            `'${context.sourceDocId}'. Entry ids embed the document id and the ` +
+            "author's metadataSignature binds both, so the original signatures " +
+            "cannot carry over. Use targetDocId 'same' to preserve authorship."));
+    }
+    if (!sameKey) {
+        reasons.push(reason("different_key", `The copy is encrypted under key '${context.targetDecryptionKeyId}' instead ` +
+            `of '${context.sourceDecryptionKeyId}'. Re-encryption changes contentHash, ` +
+            "which the author's metadataSignature binds."));
+    }
+    const canPreserve = reasons.length === 0;
+    if (wantsPreserve && !canPreserve) {
+        return {
+            allowed: false,
+            strategy: "replay",
+            authorshipPreserved: false,
+            willMergeIntoExisting: context.targetHasDocId,
+            sameStore: context.sameStore,
+            requiresReEncryption,
+            reasons,
+        };
+    }
+    const strategy = wantsPreserve ? "graft" : "replay";
+    return {
+        allowed: true,
+        strategy,
+        authorshipPreserved: strategy === "graft",
+        willMergeIntoExisting: context.targetHasDocId,
+        sameStore: context.sameStore,
+        requiresReEncryption,
+        // A successful graft has nothing to explain. A replay lists what would have
+        // had to be true for authorship to survive, so callers can tell an
+        // unavoidable re-author from an accidental one.
+        reasons: strategy === "graft" ? [] : reasons,
+    };
+}
+/**
+ * Turn an unusable {@link CopyFeasibility} into the error thrown by
+ * `copyDocumentTo` / `copyDocumentsTo`.
+ */
+function copyFeasibilityError(feasibility) {
+    const detail = feasibility.reasons
+        .map((entry) => `[${entry.code}] ${entry.message}`)
+        .join(" ");
+    return new Error(`Document copy is not possible with the requested options. ${detail}`);
+}
+//# sourceMappingURL=feasibility.js.map

package/dist/core/copy/feasibility.js.map

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

package/dist/core/copy/flatten.d.ts

@@ -0,0 +1,55 @@
+/**
+ * The flatten copy strategy.
+ *
+ * Reads the source document's state — at its head, or as of
+ * {@link CopyDocumentOptions.atTimestamp} — and writes it into the target as a
+ * brand-new document with a single revision. History, original authors and the
+ * CRDT structure are all deliberately left behind; what arrives is a clean
+ * document that happens to have the same content.
+ *
+ * Unlike the two history strategies this one goes entirely through the public
+ * document API, which is what makes it work regardless of tenant, key or
+ * document id: `createDocument` + one `changeDoc`, with attachments re-uploaded
+ * through `addAttachmentStream` so they get fresh chunk ids in the target.
+ *
+ * **Caveat worth knowing:** materializing an Automerge document to plain JS
+ * collapses its text fields into ordinary strings. A flattened copy therefore
+ * loses the character-level text CRDT structure, and concurrent edits to those
+ * fields merge as whole-value conflicts rather than per-character. That is
+ * usually the right trade for a fresh document, but it is the reason
+ * `mode: "history"` exists.
+ *
+ * @module
+ */
+import type { CopyEngineHost } from "./host";
+import type { CopyContext } from "./feasibility";
+import type { CopyProgressReporter } from "./copyDocument";
+import type { CopyDocumentOptions, CopyDocumentResult } from "./types";
+/**
+ * Document-level provenance for a flattened copy.
+ *
+ * Per-change provenance would be meaningless here — the copy has exactly one
+ * change, authored by the copying user, that corresponds to no single source
+ * revision — so the origin is recorded once in the payload instead, which also
+ * keeps flatten free of any store-format concern.
+ */
+export interface FlattenedDocumentProvenance {
+    /** When the copy ran (epoch millis). */
+    copiedAt: number;
+    /** Tenant the content came from. */
+    sourceTenantId: string;
+    /** Database the content came from. */
+    sourceDbId: string;
+    /** Document the content came from. */
+    sourceDocId: string;
+    /**
+     * The point in the source's history that was captured, when the caller asked
+     * for a specific one via {@link CopyDocumentOptions.atTimestamp}.
+     */
+    sourceAtTimestamp?: number;
+    /** Signing key of the user who made the copy. */
+    copiedByPublicKey: string;
+}
+/** Flatten one document into the target database. */
+export declare function flattenDocument(source: CopyEngineHost, target: CopyEngineHost, context: CopyContext, options: CopyDocumentOptions, reporter: CopyProgressReporter): Promise<CopyDocumentResult>;
+//# sourceMappingURL=flatten.d.ts.map

package/dist/core/copy/flatten.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flatten.d.ts","sourceRoot":"","sources":["../../../src/core/copy/flatten.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AAC7C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAC3D,OAAO,KAAK,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAEvE;;;;;;;GAOG;AACH,MAAM,WAAW,2BAA2B;IAC1C,wCAAwC;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB,oCAAoC;IACpC,cAAc,EAAE,MAAM,CAAC;IACvB,sCAAsC;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,sCAAsC;IACtC,WAAW,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,iDAAiD;IACjD,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAqBD,qDAAqD;AACrD,wBAAsB,eAAe,CACnC,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,cAAc,EACtB,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE,mBAAmB,EAC5B,QAAQ,EAAE,oBAAoB,GAC7B,OAAO,CAAC,kBAAkB,CAAC,CAyI7B"}

package/dist/core/copy/flatten.js

@@ -0,0 +1,155 @@
+"use strict";
+/**
+ * The flatten copy strategy.
+ *
+ * Reads the source document's state — at its head, or as of
+ * {@link CopyDocumentOptions.atTimestamp} — and writes it into the target as a
+ * brand-new document with a single revision. History, original authors and the
+ * CRDT structure are all deliberately left behind; what arrives is a clean
+ * document that happens to have the same content.
+ *
+ * Unlike the two history strategies this one goes entirely through the public
+ * document API, which is what makes it work regardless of tenant, key or
+ * document id: `createDocument` + one `changeDoc`, with attachments re-uploaded
+ * through `addAttachmentStream` so they get fresh chunk ids in the target.
+ *
+ * **Caveat worth knowing:** materializing an Automerge document to plain JS
+ * collapses its text fields into ordinary strings. A flattened copy therefore
+ * loses the character-level text CRDT structure, and concurrent edits to those
+ * fields merge as whole-value conflicts rather than per-character. That is
+ * usually the right trade for a fresh document, but it is the reason
+ * `mode: "history"` exists.
+ *
+ * @module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenDocument = flattenDocument;
+const types_1 = require("../types");
+/** Payload key holding {@link FlattenedDocumentProvenance}. */
+const PROVENANCE_FIELD = "_provenance";
+/**
+ * Materialize the source payload as plain data the target can accept.
+ *
+ * `_`-prefixed keys are MindooDB's own namespace (`_attachments`,
+ * `_lastModified`) and are managed by the target database, so they are dropped
+ * rather than copied over stale.
+ */
+function copyablePayload(payload) {
+    const copy = {};
+    for (const [key, value] of Object.entries(payload)) {
+        if (key.startsWith("_"))
+            continue;
+        copy[key] = structuredClone(value);
+    }
+    return copy;
+}
+/** Flatten one document into the target database. */
+async function flattenDocument(source, target, context, options, reporter) {
+    const { sourceDocId, targetDocId } = context;
+    reporter.emit("planning", `Reading ${sourceDocId} for a flattened copy`);
+    const sourceDoc = options.atTimestamp != null
+        ? await source.db.getDocumentAtTimestamp(sourceDocId, options.atTimestamp)
+        : await source.db.getDocument(sourceDocId);
+    if (!sourceDoc) {
+        throw new Error(options.atTimestamp != null
+            ? `Document ${sourceDocId} did not exist at timestamp ${options.atTimestamp}.`
+            : `Document ${sourceDocId} was not found in database ${context.sourceDbId}.`);
+    }
+    const usesGeneratedId = (options.targetDocId ?? "new") === "new";
+    if (!usesGeneratedId && !types_1.CUSTOM_DOC_ID_REGEX.test(targetDocId)) {
+        // Ids minted by MindooDB may start with a digit, which the caller-provided
+        // id rules reject. Say so here rather than letting createDocument fail with
+        // a message that gives no hint about the copy.
+        throw new Error(`Cannot flatten into document id '${targetDocId}': caller-provided ids must ` +
+            "match /^[A-Za-z][A-Za-z0-9_]*$/. Copy with mode 'history' to keep a " +
+            "MindooDB-generated id, or pass an explicit targetDocId that satisfies the rule.");
+    }
+    const copiedByPublicKey = options.signingKeyPair?.publicKey ??
+        (await target.tenant.getCurrentUserId()).userSigningPublicKey;
+    const payload = copyablePayload(sourceDoc.getData());
+    let provenance;
+    if (options.provenance !== false) {
+        provenance = {
+            copiedAt: Date.now(),
+            sourceTenantId: context.sourceTenantId,
+            sourceDbId: context.sourceDbId,
+            sourceDocId,
+            copiedByPublicKey,
+        };
+        if (options.atTimestamp != null) {
+            // Automerge rejects an explicit `undefined`, so optional fields have to be
+            // left out entirely rather than assigned an absent value.
+            provenance.sourceAtTimestamp = options.atTimestamp;
+        }
+    }
+    const includeAttachments = options.includeAttachments !== false;
+    const sourceAttachments = includeAttachments ? sourceDoc.getAttachments() : [];
+    // Fold the payload into the `doc_create` change instead of writing a second
+    // entry for it. A caller-provided id normally cannot do this: it is seeded
+    // from a hard-coded Automerge change so independent replicas converge on the
+    // same hash, and baking content into that change would diverge it per
+    // document — `createDocument` rejects the combination. `assumeUniqueId` is
+    // the caller's assertion that concurrent same-id creation cannot happen, so
+    // convergence is moot and the create can take the generated-id path.
+    //
+    // `copyablePayload` has already dropped every `_`-prefixed key, so nothing is
+    // silently lost to `initialValues`' own reserved-field sanitizer.
+    const assumeUniqueId = !usesGeneratedId && options.assumeUniqueTargetDocId === true;
+    const seedPayloadIntoCreate = usesGeneratedId || assumeUniqueId;
+    const idsBefore = new Set((await target.store.findNewEntriesForDoc([], targetDocId)).map((entry) => entry.id));
+    reporter.emit("transferring", `Writing flattened copy as ${targetDocId}`);
+    const targetDoc = await target.db.createDocument({
+        ...(usesGeneratedId
+            ? { idPrefix: options.idPrefix }
+            : { id: targetDocId, assumeUniqueId }),
+        ...(seedPayloadIntoCreate ? { initialValues: payload } : {}),
+        decryptionKeyId: context.targetDecryptionKeyId,
+        signingKeyPair: options.signingKeyPair,
+        signingKeyPassword: options.signingKeyPassword,
+        bypassAccessControlPrecheck: options.bypassAccessControlPrecheck,
+    });
+    // Whatever the create could not carry. `_provenance` is in MindooDB's
+    // reserved namespace, which `initialValues` refuses to seed, so asking for
+    // provenance costs the second entry — the price of keeping the marker out of
+    // the caller's field namespace, where a later re-copy would treat it as
+    // ordinary content.
+    const needsFollowUpChange = !seedPayloadIntoCreate || provenance !== undefined || sourceAttachments.length > 0;
+    if (needsFollowUpChange) {
+        await target.db.changeDoc(targetDoc, async (draft) => {
+            if (!seedPayloadIntoCreate) {
+                Object.assign(draft.getData(), payload);
+            }
+            if (provenance) {
+                draft.getData()[PROVENANCE_FIELD] = provenance;
+            }
+            for (const attachment of sourceAttachments) {
+                if (options.signal?.aborted)
+                    break;
+                await draft.addAttachmentStream(sourceDoc.streamAttachment(attachment.attachmentId), attachment.fileName, attachment.mimeType);
+            }
+        }, {
+            signingKeyPair: options.signingKeyPair,
+            signingKeyPassword: options.signingKeyPassword,
+            bypassAccessControlPrecheck: options.bypassAccessControlPrecheck,
+        });
+    }
+    const written = (await target.store.findNewEntriesForDoc([], targetDoc.getId())).filter((entry) => !idsBefore.has(entry.id));
+    reporter.copiedEntries += written.length;
+    for (const entry of written) {
+        reporter.copiedBytes += entry.encryptedSize;
+    }
+    reporter.copiedAttachments += sourceAttachments.length;
+    reporter.emit("complete", `Flattened ${sourceDocId} into ${targetDoc.getId()}`);
+    return {
+        sourceDocId,
+        targetDocId: targetDoc.getId(),
+        strategy: "flatten",
+        authorshipPreserved: false,
+        mergedIntoExisting: context.targetHasDocId,
+        copiedEntries: written.length,
+        copiedBytes: written.reduce((total, entry) => total + entry.encryptedSize, 0),
+        copiedAttachments: sourceAttachments.length,
+        cancelled: options.signal?.aborted ?? false,
+    };
+}
+//# sourceMappingURL=flatten.js.map

package/dist/core/copy/flatten.js.map

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