@remnic/core 1.1.11 → 1.1.13

package/dist/transfer/capsule-export.d.ts

@@ -0,0 +1,113 @@
+import { CapsuleBlock, ExportManifestV2 } from './types.js';
+import 'zod';
+
+/**
+ * Options accepted by {@link exportCapsule}.
+ *
+ * `name` — capsule id, validated against {@link CAPSULE_ID_PATTERN}. The id
+ * also forms the manifest's `capsule.id` and the archive filename.
+ *
+ * `root` — absolute or cwd-relative path to the memory directory to export.
+ *
+ * `since` — optional ISO-8601 timestamp; only files with `mtime >= since`
+ * are included.
+ *
+ * `includeKinds` — optional allow-list of top-level subdirectory names
+ * (e.g. `facts`, `entities`, `corrections`, `transcripts`). When set, files
+ * directly under {@link root} are excluded and only files whose first path
+ * segment is in the allow-list are kept. Pass `transcripts` here explicitly
+ * to opt-in transcripts (they are excluded by default).
+ *
+ * `peerIds` — optional allow-list restricting the `peers/` tree to files
+ * under `peers/<peerId>/...`. When omitted the entire `peers/` tree is
+ * included (subject to {@link includeKinds}). When set to an empty array
+ * the `peers/` tree is excluded entirely.
+ *
+ * `outDir` — optional output directory. Defaults to `<root>/.capsules`.
+ *
+ * `pluginVersion` — recorded in the manifest. Defaults to `"0.0.0"` so
+ * tests do not need to thread a version through; production callers SHOULD
+ * pass the running plugin version.
+ *
+ * `capsule` — optional overrides for the manifest's `capsule` block. The
+ * caller may pass any subset; remaining fields are filled with conservative
+ * defaults documented inline below.
+ *
+ * `now` — optional clock override (ms epoch) used for `manifest.createdAt`.
+ * Tests pass a fixed value for deterministic output.
+ *
+ * `encrypt` — when `true`, encrypt the output archive using the secure-store
+ * master key for `memoryDir`. The keyring must be unlocked before calling
+ * (`remnic secure-store unlock`). The plaintext `.capsule.json.gz` is written
+ * first, then encrypted to `<name>.capsule.json.gz.enc`; the plaintext is
+ * removed after successful encryption. Requires `memoryDir` to be provided.
+ *
+ * `memoryDir` — required when `encrypt` is `true`. The memory directory whose
+ * secure-store keyring holds the master key.
+ */
+interface ExportCapsuleOptions {
+    name: string;
+    root: string;
+    since?: string;
+    includeKinds?: readonly string[];
+    peerIds?: readonly string[];
+    outDir?: string;
+    pluginVersion?: string;
+    capsule?: Partial<Omit<CapsuleBlock, "id">>;
+    now?: number;
+    /**
+     * When `true`, encrypt the output archive. Requires the secure-store to be
+     * unlocked and `memoryDir` to be set. The plaintext `.capsule.json.gz` is
+     * replaced by `<name>.capsule.json.gz.enc` on success.
+     */
+    encrypt?: boolean;
+    /**
+     * Memory directory whose secure-store keyring holds the master key. Required
+     * when `encrypt` is `true`; ignored otherwise.
+     */
+    memoryDir?: string;
+    /**
+     * When `true`, include the `transcripts/` directory in the export even
+     * though it is excluded by default. Using this flag avoids hard-coding an
+     * explicit `includeKinds` allow-list that would inadvertently drop other
+     * valid memory directories (`peers/`, `forks/`, etc.). (Cursor / #747)
+     *
+     * Ignored when `includeKinds` is provided and already contains
+     * `"transcripts"`.
+     */
+    includeTranscripts?: boolean;
+}
+interface ExportCapsuleResult {
+    archivePath: string;
+    manifestPath: string;
+    manifest: ExportManifestV2;
+    /** When the export was encrypted, the `.enc` path. `null` when unencrypted. */
+    encryptedArchivePath: string | null;
+}
+/**
+ * Pure function that exports a memory directory as a portable, capsule-aware
+ * V2 bundle.
+ *
+ * The output is a single `.capsule.json.gz` archive containing the entire
+ * `ExportBundleV2` (manifest + records) plus a sidecar `manifest.json` for
+ * cheap inspection. The bundle format is intentionally identical to the
+ * existing `export-json` shape so PR 3/6's importer can reuse the V1 code
+ * path with only a manifest version-dispatch.
+ *
+ * Determinism guarantees:
+ *  - `manifest.files` and `bundle.records` are sorted by posix path.
+ *  - `manifest.createdAt` is taken from {@link ExportCapsuleOptions.now}
+ *    when provided.
+ *  - The archive is gzip-compressed with default settings; no timestamp is
+ *    embedded (Node's `gzipSync` does not write a header timestamp when
+ *    using the synchronous helper, so byte-identical outputs are possible
+ *    given identical inputs).
+ *
+ * Empty result handling: a capsule with zero matching files is still a
+ * valid capsule and produces a well-formed manifest with an empty `files`
+ * array and an archive containing the empty bundle.
+ */
+declare function exportCapsule(opts: ExportCapsuleOptions): Promise<ExportCapsuleResult>;
+declare function isValidCapsuleSince(since: string): boolean;
+
+export { type ExportCapsuleOptions, type ExportCapsuleResult, exportCapsule, isValidCapsuleSince };

package/dist/transfer/capsule-export.js

@@ -0,0 +1,19 @@
+import {
+  exportCapsule,
+  isValidCapsuleSince
+} from "../chunk-2F2W355T.js";
+import "../chunk-KNKUID7G.js";
+import "../chunk-WEHSQBFR.js";
+import "../chunk-J4EB7DNW.js";
+import "../chunk-I6K5FBRQ.js";
+import "../chunk-AGZQD76C.js";
+import "../chunk-BJMBJZ2Y.js";
+import "../chunk-UKJAGEXH.js";
+import "../chunk-FP2373TW.js";
+import "../chunk-A6XUJE5D.js";
+import "../chunk-PZ5AY32C.js";
+export {
+  exportCapsule,
+  isValidCapsuleSince
+};
+//# sourceMappingURL=capsule-export.js.map

package/dist/transfer/capsule-export.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/transfer/capsule-import.d.ts

@@ -0,0 +1,124 @@
+import { VersioningConfig, VersioningLogger } from '../page-versioning.js';
+import { ExportManifestV2 } from './types.js';
+export { CapsuleBlock } from './types.js';
+import 'zod';
+
+/**
+ * Conflict-resolution mode for {@link importCapsule}. Inverse of the
+ * `mode` selector in PR 4/6's CLI surface.
+ *
+ *  - `"skip"` (default) — when a target file already exists at the same
+ *    relative path, leave it untouched. The corresponding record is reported
+ *    via {@link ImportCapsuleResult.skipped}.
+ *  - `"overwrite"` — when a target file exists, snapshot the prior content
+ *    via {@link createVersion} (gotcha #54: write-before-delete; gotcha #25:
+ *    don't destroy old state until new state is confirmed), then write the
+ *    incoming content. The snapshot's `note` includes the source capsule id.
+ *  - `"fork"` — never overwrite. Every record is rebased under
+ *    `forks/<capsule-id>/<original-path>` and any YAML-frontmatter `id:`
+ *    field is rewritten to a new fork-scoped value. The original tree is
+ *    not touched.
+ *
+ * The mode is selected once per call and applied uniformly to every record
+ * in the bundle. Mixed-mode imports are not supported by design — that
+ * would let a single corrupted manifest silently land partial state.
+ */
+type ImportCapsuleMode = "skip" | "overwrite" | "fork";
+/**
+ * Options accepted by {@link importCapsule}.
+ *
+ * `archivePath` — absolute or cwd-relative path to a `.capsule.json.gz`
+ * archive produced by `exportCapsule`. The archive must contain a V2
+ * bundle (`schemaVersion: 2`); V1 archives are rejected.
+ *
+ * `root` — absolute or cwd-relative path to the memory directory that
+ * will receive the records. Must be an existing directory.
+ *
+ * `mode` — see {@link ImportCapsuleMode}. Defaults to `"skip"`.
+ *
+ * `versioning` — optional page-versioning config used by `mode: "overwrite"`
+ * to snapshot prior content before replacing it. Snapshots are skipped when
+ * not provided or when `enabled === false`. Tests pass an enabled config
+ * to assert snapshot creation; production callers thread the
+ * orchestrator's resolved versioning config.
+ *
+ * `log` — optional logger forwarded to {@link createVersion}.
+ *
+ * `now` — optional clock override (ms epoch) used to derive deterministic
+ * fork ids in tests. Production callers omit this.
+ */
+interface ImportCapsuleOptions {
+    archivePath: string;
+    root: string;
+    mode?: ImportCapsuleMode;
+    versioning?: VersioningConfig;
+    log?: VersioningLogger;
+    now?: number;
+    /**
+     * Memory directory whose secure-store keyring is used when the archive is
+     * encrypted. Required when `archivePath` ends with `.enc` or when the file
+     * starts with the REMNIC-ENC magic header. If `memoryDir` is omitted and the
+     * archive turns out to be encrypted, `importCapsule` throws a clear error
+     * rather than silently failing.
+     *
+     * When provided and the archive is NOT encrypted, the value is ignored.
+     */
+    memoryDir?: string;
+}
+interface ImportCapsuleSkippedRecord {
+    /** Original record path (capsule-relative, posix). */
+    path: string;
+    /**
+     * Why this record was not written.
+     *
+     * `"exists"` — the target path already existed and the mode was `"skip"`,
+     * OR the computed fork path already existed in fork mode.
+     *
+     * `"checksum_mismatch"` is intentionally absent: a checksum failure aborts
+     * the import entirely (fail-closed) rather than skipping the offending
+     * record, so no `ImportCapsuleSkippedRecord` is ever produced for it.
+     */
+    reason: "exists";
+}
+interface ImportCapsuleImportedRecord {
+    /** Capsule-relative posix path the record carried. */
+    sourcePath: string;
+    /** Memory-dir-relative posix path the file was written to. */
+    targetPath: string;
+    /** Whether a prior version snapshot was taken (overwrite-mode only). */
+    snapshotted: boolean;
+    /** Whether the frontmatter `id:` field was rewritten (fork-mode only). */
+    rewroteId: boolean;
+}
+interface ImportCapsuleResult {
+    /** Records that landed on disk. */
+    imported: ImportCapsuleImportedRecord[];
+    /** Records that were not written. */
+    skipped: ImportCapsuleSkippedRecord[];
+    /** The manifest decoded from the archive. */
+    manifest: ExportManifestV2;
+}
+/**
+ * Pure async function that imports a capsule archive into a memory
+ * directory. Inverse of {@link import("./capsule-export.js").exportCapsule}.
+ *
+ * Sequence:
+ *   1. Read + gunzip + JSON.parse the archive.
+ *   2. Validate the bundle through `parseExportBundle` (V1 rejected).
+ *   3. Verify each record's content sha256 against the manifest entry.
+ *      Any mismatch aborts the import BEFORE any file is written —
+ *      partial-write recovery would require a full rollback we cannot
+ *      offer cheaply, so we fail closed (gotcha #25).
+ *   4. Apply the selected {@link ImportCapsuleMode} to every record.
+ *
+ * Determinism guarantees:
+ *  - Imported records are returned sorted by `sourcePath`.
+ *  - Skipped records are returned sorted by `path`.
+ *  - Fork-mode rebases under a stable `forks/<capsule-id>/` prefix so
+ *    repeated fork imports of the same capsule shape land in predictable
+ *    locations (subsequent fork imports still skip-on-exist because the
+ *    target tree is computed from the source path).
+ */
+declare function importCapsule(opts: ImportCapsuleOptions): Promise<ImportCapsuleResult>;
+
+export { type ImportCapsuleImportedRecord, type ImportCapsuleMode, type ImportCapsuleOptions, type ImportCapsuleResult, type ImportCapsuleSkippedRecord, importCapsule };

package/dist/transfer/capsule-import.js

@@ -0,0 +1,16 @@
+import {
+  importCapsule
+} from "../chunk-GGKRUQOO.js";
+import "../chunk-FAAFWE4G.js";
+import "../chunk-KNKUID7G.js";
+import "../chunk-WEHSQBFR.js";
+import "../chunk-AGZQD76C.js";
+import "../chunk-BJMBJZ2Y.js";
+import "../chunk-UKJAGEXH.js";
+import "../chunk-FP2373TW.js";
+import "../chunk-A6XUJE5D.js";
+import "../chunk-PZ5AY32C.js";
+export {
+  importCapsule
+};
+//# sourceMappingURL=capsule-import.js.map

package/dist/transfer/capsule-import.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/transfer/constants.d.ts

@@ -0,0 +1,13 @@
+declare const EXPORT_FORMAT: "openclaw-engram-export";
+declare const EXPORT_SCHEMA_VERSION: 1;
+/**
+ * Schema version for capsule-aware (V2) export manifests. See
+ * {@link ../types.ts} `ExportManifestV2Schema` for the wire format.
+ *
+ * V1 manifests remain the default for non-capsule exports
+ * (`exportJsonBundle` / `exportMarkdownBundle`). V2 is emitted by the
+ * capsule export pipeline only.
+ */
+declare const CAPSULE_SCHEMA_VERSION: 2;
+
+export { CAPSULE_SCHEMA_VERSION, EXPORT_FORMAT, EXPORT_SCHEMA_VERSION };

package/dist/transfer/constants.js

@@ -0,0 +1,12 @@
+import {
+  CAPSULE_SCHEMA_VERSION,
+  EXPORT_FORMAT,
+  EXPORT_SCHEMA_VERSION
+} from "../chunk-J4EB7DNW.js";
+import "../chunk-PZ5AY32C.js";
+export {
+  CAPSULE_SCHEMA_VERSION,
+  EXPORT_FORMAT,
+  EXPORT_SCHEMA_VERSION
+};
+//# sourceMappingURL=constants.js.map

package/dist/transfer/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/transfer/export-json.d.ts

@@ -0,0 +1,11 @@
+interface ExportCommonOptions {
+    memoryDir: string;
+    outDir: string;
+    includeTranscripts?: boolean;
+    includeWorkspaceIdentity?: boolean;
+    workspaceDir?: string;
+    pluginVersion: string;
+}
+declare function exportJsonBundle(opts: ExportCommonOptions): Promise<void>;
+
+export { type ExportCommonOptions, exportJsonBundle };

package/dist/transfer/export-json.js

@@ -0,0 +1,11 @@
+import {
+  exportJsonBundle
+} from "../chunk-GIF42EW3.js";
+import "../chunk-J4EB7DNW.js";
+import "../chunk-I6K5FBRQ.js";
+import "../chunk-AGZQD76C.js";
+import "../chunk-PZ5AY32C.js";
+export {
+  exportJsonBundle
+};
+//# sourceMappingURL=export-json.js.map

package/dist/transfer/export-json.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/transfer/export-md.d.ts

@@ -0,0 +1,10 @@
+interface ExportMdOptions {
+    memoryDir: string;
+    outDir: string;
+    includeTranscripts?: boolean;
+    pluginVersion: string;
+}
+declare function exportMarkdownBundle(opts: ExportMdOptions): Promise<void>;
+declare function looksLikeEngramMdExport(fromDir: string): Promise<boolean>;
+
+export { type ExportMdOptions, exportMarkdownBundle, looksLikeEngramMdExport };

package/dist/transfer/export-md.js

@@ -0,0 +1,13 @@
+import {
+  exportMarkdownBundle,
+  looksLikeEngramMdExport
+} from "../chunk-6H2TESSP.js";
+import "../chunk-J4EB7DNW.js";
+import "../chunk-I6K5FBRQ.js";
+import "../chunk-AGZQD76C.js";
+import "../chunk-PZ5AY32C.js";
+export {
+  exportMarkdownBundle,
+  looksLikeEngramMdExport
+};
+//# sourceMappingURL=export-md.js.map

package/dist/transfer/export-md.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/transfer/export-sqlite.d.ts

@@ -0,0 +1,9 @@
+interface ExportSqliteOptions {
+    memoryDir: string;
+    outFile: string;
+    includeTranscripts?: boolean;
+    pluginVersion: string;
+}
+declare function exportSqlite(opts: ExportSqliteOptions): Promise<void>;
+
+export { type ExportSqliteOptions, exportSqlite };

package/dist/transfer/export-sqlite.js

@@ -0,0 +1,12 @@
+import {
+  exportSqlite
+} from "../chunk-66DHUKLO.js";
+import "../chunk-Z734BLO3.js";
+import "../chunk-3HPAPHUK.js";
+import "../chunk-I6K5FBRQ.js";
+import "../chunk-AGZQD76C.js";
+import "../chunk-PZ5AY32C.js";
+export {
+  exportSqlite
+};
+//# sourceMappingURL=export-sqlite.js.map

package/dist/transfer/export-sqlite.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/transfer/fs-utils.d.ts

@@ -0,0 +1,61 @@
+declare function sha256File(filePath: string): Promise<{
+    sha256: string;
+    bytes: number;
+}>;
+declare function sha256Bytes(content: Uint8Array): {
+    sha256: string;
+    bytes: number;
+};
+declare function sha256String(content: string): {
+    sha256: string;
+    bytes: number;
+};
+declare function readUtf8FileStrict(filePath: string): Promise<{
+    content: string;
+    sha256: string;
+    bytes: number;
+}>;
+declare function writeJsonFile(filePath: string, value: unknown): Promise<void>;
+declare function readJsonFile<T>(filePath: string): Promise<T>;
+declare function listFilesRecursive(rootDir: string): Promise<string[]>;
+declare function ensureDirExists(dirPath: string): Promise<void>;
+declare function fileExists(filePath: string): Promise<boolean>;
+declare function toPosixRelPath(absPath: string, rootDir: string): string;
+declare function fromPosixRelPath(relPath: string): string;
+interface SafeArchiveRoot {
+    abs: string;
+    real: string;
+    errorPrefix: string;
+    argName: string;
+}
+declare function prepareSafeArchiveRoot(absPath: string, errorPrefix: string, argName: string): Promise<SafeArchiveRoot>;
+declare function validateArchiveRelativePath(relPath: string, errorPrefix: string): string;
+declare function resolveSafeArchiveTarget(root: SafeArchiveRoot, relPath: string): Promise<string>;
+/**
+ * Return true when {@link absPath} is the same as {@link rootReal} or a
+ * descendant. {@link rootReal} should be the value returned by
+ * `realpath(rootAbs)` so that symlinked subdirectories are detected.
+ */
+declare function isPathInsideRoot(rootReal: string, absPath: string): boolean;
+/**
+ * Assert that {@link absPath} is an existing directory and is not itself a
+ * symlink. `existsSync` returns true for files (gotcha #24); a stat-based
+ * check is required. Symlinked roots are rejected up-front so an attacker
+ * cannot hand the importer a `~/import-target` link → `/etc` and have writes
+ * silently follow the link (Codex P1 round 5 thread on PR #741).
+ */
+declare function assertIsDirectoryNotSymlink(absPath: string, errorPrefix: string, argName: string): Promise<void>;
+/**
+ * Walk upward from {@link targetAbs} to find the nearest existing ancestor,
+ * resolve it via `fs.realpath` (which follows symlinks), then re-append the
+ * remaining suffix and verify the result is inside {@link rootReal}.
+ *
+ * This catches the case where an existing subdirectory at any point in the
+ * path is a symlink that points outside the intended root. Because the file
+ * does not exist yet we cannot realpath it directly; we resolve the deepest
+ * existing prefix and re-apply the non-existent suffix. Callers must ensure
+ * {@link rootReal} was already resolved via `realpath`.
+ */
+declare function assertRealpathInsideRoot(rootReal: string, targetAbs: string, sourcePath: string, errorPrefix: string): Promise<void>;
+
+export { type SafeArchiveRoot, assertIsDirectoryNotSymlink, assertRealpathInsideRoot, ensureDirExists, fileExists, fromPosixRelPath, isPathInsideRoot, listFilesRecursive, prepareSafeArchiveRoot, readJsonFile, readUtf8FileStrict, resolveSafeArchiveTarget, sha256Bytes, sha256File, sha256String, toPosixRelPath, validateArchiveRelativePath, writeJsonFile };

package/dist/transfer/fs-utils.js

@@ -0,0 +1,40 @@
+import {
+  assertIsDirectoryNotSymlink,
+  assertRealpathInsideRoot,
+  ensureDirExists,
+  fileExists,
+  fromPosixRelPath,
+  isPathInsideRoot,
+  listFilesRecursive,
+  prepareSafeArchiveRoot,
+  readJsonFile,
+  readUtf8FileStrict,
+  resolveSafeArchiveTarget,
+  sha256Bytes,
+  sha256File,
+  sha256String,
+  toPosixRelPath,
+  validateArchiveRelativePath,
+  writeJsonFile
+} from "../chunk-AGZQD76C.js";
+import "../chunk-PZ5AY32C.js";
+export {
+  assertIsDirectoryNotSymlink,
+  assertRealpathInsideRoot,
+  ensureDirExists,
+  fileExists,
+  fromPosixRelPath,
+  isPathInsideRoot,
+  listFilesRecursive,
+  prepareSafeArchiveRoot,
+  readJsonFile,
+  readUtf8FileStrict,
+  resolveSafeArchiveTarget,
+  sha256Bytes,
+  sha256File,
+  sha256String,
+  toPosixRelPath,
+  validateArchiveRelativePath,
+  writeJsonFile
+};
+//# sourceMappingURL=fs-utils.js.map

package/dist/transfer/fs-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/transfer/import-json.d.ts

@@ -0,0 +1,16 @@
+import { C as ConflictPolicy } from '../conflict-policy-DyJ2wd-h.js';
+
+interface ImportJsonOptions {
+    targetMemoryDir: string;
+    fromDir: string;
+    conflict?: ConflictPolicy;
+    dryRun?: boolean;
+    workspaceDir?: string;
+}
+declare function importJsonBundle(opts: ImportJsonOptions): Promise<{
+    written: number;
+    skipped: number;
+}>;
+declare function looksLikeEngramJsonExport(fromDir: string): Promise<boolean>;
+
+export { ConflictPolicy, type ImportJsonOptions, importJsonBundle, looksLikeEngramJsonExport };

package/dist/transfer/import-json.js

@@ -0,0 +1,13 @@
+import {
+  importJsonBundle,
+  looksLikeEngramJsonExport
+} from "../chunk-W4L6CZKA.js";
+import "../chunk-3JXBXXM2.js";
+import "../chunk-WEHSQBFR.js";
+import "../chunk-AGZQD76C.js";
+import "../chunk-PZ5AY32C.js";
+export {
+  importJsonBundle,
+  looksLikeEngramJsonExport
+};
+//# sourceMappingURL=import-json.js.map

package/dist/transfer/import-json.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/transfer/import-md.d.ts

@@ -0,0 +1,14 @@
+import { C as ConflictPolicy } from '../conflict-policy-DyJ2wd-h.js';
+
+interface ImportMdOptions {
+    targetMemoryDir: string;
+    fromDir: string;
+    conflict?: ConflictPolicy;
+    dryRun?: boolean;
+}
+declare function importMarkdownBundle(opts: ImportMdOptions): Promise<{
+    written: number;
+    skipped: number;
+}>;
+
+export { ConflictPolicy, type ImportMdOptions, importMarkdownBundle };

package/dist/transfer/import-md.js

@@ -0,0 +1,11 @@
+import {
+  importMarkdownBundle
+} from "../chunk-TK4UEOSK.js";
+import "../chunk-3JXBXXM2.js";
+import "../chunk-WEHSQBFR.js";
+import "../chunk-AGZQD76C.js";
+import "../chunk-PZ5AY32C.js";
+export {
+  importMarkdownBundle
+};
+//# sourceMappingURL=import-md.js.map

package/dist/transfer/import-md.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/transfer/import-sqlite.d.ts

@@ -0,0 +1,14 @@
+import { C as ConflictPolicy } from '../conflict-policy-DyJ2wd-h.js';
+
+interface ImportSqliteOptions {
+    targetMemoryDir: string;
+    fromFile: string;
+    conflict?: ConflictPolicy;
+    dryRun?: boolean;
+}
+declare function importSqlite(opts: ImportSqliteOptions): Promise<{
+    written: number;
+    skipped: number;
+}>;
+
+export { ConflictPolicy, type ImportSqliteOptions, importSqlite };

package/dist/transfer/import-sqlite.js

@@ -0,0 +1,12 @@
+import {
+  importSqlite
+} from "../chunk-TFO23QT4.js";
+import "../chunk-Z734BLO3.js";
+import "../chunk-3JXBXXM2.js";
+import "../chunk-3HPAPHUK.js";
+import "../chunk-AGZQD76C.js";
+import "../chunk-PZ5AY32C.js";
+export {
+  importSqlite
+};
+//# sourceMappingURL=import-sqlite.js.map

package/dist/transfer/import-sqlite.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/transfer/sqlite-schema.d.ts

@@ -0,0 +1,4 @@
+declare const SQLITE_SCHEMA_VERSION: 1;
+declare const SQLITE_TABLES_SQL = "\nCREATE TABLE IF NOT EXISTS meta (\n  key TEXT PRIMARY KEY,\n  value TEXT NOT NULL\n);\n\nCREATE TABLE IF NOT EXISTS files (\n  path_rel TEXT PRIMARY KEY,\n  bytes INTEGER NOT NULL,\n  sha256 TEXT NOT NULL,\n  content TEXT NOT NULL\n);\n";
+
+export { SQLITE_SCHEMA_VERSION, SQLITE_TABLES_SQL };

package/dist/transfer/sqlite-schema.js

@@ -0,0 +1,10 @@
+import {
+  SQLITE_SCHEMA_VERSION,
+  SQLITE_TABLES_SQL
+} from "../chunk-Z734BLO3.js";
+import "../chunk-PZ5AY32C.js";
+export {
+  SQLITE_SCHEMA_VERSION,
+  SQLITE_TABLES_SQL
+};
+//# sourceMappingURL=sqlite-schema.js.map

package/dist/transfer/sqlite-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}