@dialecte/core 0.6.4 → 0.8.0

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+export * from './diagnostics';
+export * from './dialecte';
 export * from './document';
 export * from './errors';
 export * from './perf';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,UAAU,CAAA;AACxB,cAAc,QAAQ,CAAA;AACtB,cAAc,WAAW,CAAA;AACzB,cAAc,SAAS,CAAA;AACvB,cAAc,OAAO,CAAA;AAErB,mBAAmB,SAAS,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA;AAC7B,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA;AAC1B,cAAc,UAAU,CAAA;AACxB,cAAc,QAAQ,CAAA;AACtB,cAAc,WAAW,CAAA;AACzB,cAAc,SAAS,CAAA;AACvB,cAAc,OAAO,CAAA;AAErB,mBAAmB,SAAS,CAAA"}

package/dist/index.js

@@ -1,3 +1,23 @@
-import { $ as e, A as t, B as n, C as r, D as i, E as a, F as o, G as s, H as c, I as l, J as u, K as d, L as f, M as p, N as m, O as h, P as g, Q as _, R as v, S as y, T as b, U as x, W as S, X as C, Y as w, Z as T, _ as E, _t as D, a as O, at as k, b as A, c as j, ct as M, d as N, dt as P, et as F, f as I, ft as L, g as R, h as z, ht as B, i as V, it as H, j as U, k as W, l as G, lt as K, m as q, mt as J, n as Y, nt as X, o as Z, ot as Q, p as $, pt as ee, q as te, r as ne, rt as re, s as ie, st as ae, t as oe, tt as se, u as ce, ut as le, v as ue, w as de, x as fe, y as pe, z as me } from "./project-DGQAe9G9.js";
-import { F as he, I as ge, L as _e, P as ve, R as ye, z as be } from "./utils-CTBHUFs9.js";
-export { W as AnyQuery, i as AnyTransaction, N as BLOBS_SCHEMA, I as BLOB_DATA_SCHEMA, $ as CHANGELOG_SCHEMA, q as DOCUMENTS_SCHEMA, ce as DexieStore, de as Document, be as ERROR_CATALOG, G as InMemoryStore, z as META_SCHEMA, m as NOOP_PERF, g as ParseSession, oe as Project, h as Query, R as TABLE_BLOBS, E as TABLE_BLOB_PREFIX, ue as TABLE_CHANGELOG, pe as TABLE_DOCUMENTS, A as TABLE_META, fe as TABLE_RECORD_PREFIX, me as TEMP_IDB_ID_ATTRIBUTE_NAME, a as Transaction, d as applyOmit, s as applyOrder, C as applyUnwrap, D as bindExtensions, y as blobTableName, V as buildDocumentState, l as buildXmlDocument, x as collectSnapshotRecords, ve as createDialecteError, p as createPerf, B as createStagedOperations, he as defineErrors, f as downloadFile, Z as exportBlob, ie as exportDocument, k as findAncestors, re as findByAttributes, X as findDescendants, n as formatXml, F as getAttribute, se as getAttributeFullObject, _ as getAttributes, e as getAttributesFullObject, M as getChild, ae as getChildren, T as getDefinition, L as getRecord, le as getRecords, K as getRecordsByTagName, t as getSnapshot, S as getTree, ne as importDocument, ee as indexStagedDeletesByParent, Y as initEmptyDocument, o as inspectXml, ge as isKnownDialecteError, te as isOmitted, b as isTransactionContext, Q as loadLiveRecords, H as matchesAttributeFilter, J as overlayAllStaged, u as parseOmit, U as parseXmlFile, O as reconcileDocumentState, r as recordTableName, c as recordsToTree, P as resolveRecord, j as resolveStore, w as shouldStopTraversal, _e as throwDialecteError, ye as toDialecteError, v as xmlDocumentToString };
+import { G as e, H as t, K as n, U as r, V as i, W as a } from "./utils-USNkj4sT.js";
+import { A as o, C as s, D as c, E as ee, F as l, G as u, H as d, I as f, J as p, K as m, L as h, M as g, N as _, O as v, P as y, R as b, S as x, T as S, U as C, V as w, W as T, X as E, Y as D, _ as O, a as k, b as A, c as j, d as M, f as N, g as P, h as F, i as I, j as L, k as R, l as z, m as B, o as V, p as H, q as U, r as W, s as G, t as K, u as q, v as J, w as Y, x as X, y as Z, z as Q } from "./dialecte-gIPrRzni.js";
+import { B as te, F as ne, G as re, H as ie, I as ae, J as oe, K as se, L as ce, R as le, U as ue, V as de, W as fe, d as pe, g as me, h as he, i as ge, q as _e, z as ve } from "./project-key-Ch34EtFa.js";
+import { C as ye, S as be, T as xe, a as Se, b as Ce, c as we, g as Te, h as Ee, i as De, l as $, m as Oe, p as ke, s as Ae, w as je, x as Me, y as Ne } from "./same-json-value-C6kUaoyt.js";
+// src/diagnostics/diagnostics.ts
+function Pe(e, t, n) {
+	let r = e.codes[t];
+	r || a("ASSERTION_FAILED", { detail: `createDiagnostic: "${t}" is not a code of the "${e.source}" catalogue` });
+	let { ref: i, message: o = r.message, related: s, meta: c } = n;
+	return {
+		code: t,
+		severity: r.severity,
+		source: e.source,
+		message: o,
+		ref: i,
+		...s && { related: s },
+		...c && { meta: c }
+	};
+}
+function Fe(e, t) {
+	return t.catalogues.some((t) => t.source === e.source && Object.hasOwn(t.codes, e.code));
+}
+export { q as AnyQuery, j as AnyTransaction, ne as BLOBS_SCHEMA, ae as BLOB_DATA_SCHEMA, ce as CHANGELOG_SCHEMA, le as DOCUMENTS_SCHEMA, Ne as DOCUMENT_PATH_INVISIBLE_CHARACTER, Ce as DOCUMENT_PATH_MAX_BYTES, Me as DOCUMENT_PATH_SEGMENT_MAX_BYTES, be as DOCUMENT_PATH_SEPARATOR, ye as DOCUMENT_UPDATE_FIELDS, p as DexieStore, I as Document, n as ERROR_CATALOG, ve as EXPORT_BATCH_SIZE, U as InMemoryStore, te as META_SCHEMA, me as NOOP_PERF, Ae as ParseSession, W as Project, z as Query, de as TABLE_BLOBS, ie as TABLE_BLOB_PREFIX, ue as TABLE_CHANGELOG, fe as TABLE_DOCUMENTS, re as TABLE_META, se as TABLE_RECORD_PREFIX, pe as TEMP_IDB_ID_ATTRIBUTE_NAME, G as Transaction, ke as applyDocumentUpdates, P as applyOmit, F as applyOrder, A as applyUnwrap, Oe as assertDocumentPlace, w as bindExtensions, _e as blobTableName, C as buildDocumentState, H as collectSnapshotRecords, Pe as createDiagnostic, i as createDialecteError, he as createPerf, K as createProjectFactory, Q as createStagedOperations, E as defineDialecte, t as defineErrors, u as exportBlob, R as findAncestors, c as findByAttributes, ee as findDescendants, Y as getAttribute, S as getAttributeFullObject, x as getAttributes, s as getAttributesFullObject, g as getChild, L as getChildren, X as getDefinition, f as getRecord, y as getRecords, _ as getRecordsByTagName, M as getSnapshot, B as getTree, je as importOutcomeOf, h as indexStagedDeletesByParent, d as initEmptyDocument, we as inspectXml, Fe as isKnownDiagnostic, r as isKnownDialecteError, O as isOmitted, V as isTransactionContext, o as loadLiveRecords, v as matchesAttributeFilter, b as overlayAllStaged, Ee as parseDocumentPath, J as parseOmit, $ as parseXmlDocument, Se as parseXmlFile, Te as pathHolderOf, T as reconcileDocumentState, oe as recordTableName, N as recordsToTree, D as removeUnfinishedImports, l as resolveRecord, m as resolveStore, ge as runExport, De as runImport, Z as shouldStopTraversal, k as summarizeOperations, a as throwDialecteError, e as toDialecteError, xe as writeOutcomeOf };

package/dist/perf/create-perf.d.ts

@@ -6,8 +6,15 @@ import { Perf } from './perf.types';
  * callback is queued for after the current task — `stop(); report()` in the same
  * tick would otherwise read stale data). Filtering by the `dialecte::` root
  * prefix excludes measures any other library placed on the shared timeline.
+ *
+ * `timeline: false` keeps the spans in this perf only (`report()` and `snapshot()` read them, the
+ * shared timeline never sees them): what a perf whose spans another realm merges uses, so the realm
+ * running it holds them once.
+ *
+ * @intent measure how long operations take in development, collect timing spans and read a report of them
  */
-export declare function createPerf({ enabled }: {
+export declare function createPerf({ enabled, timeline, }: {
     enabled: boolean;
+    timeline?: boolean;
 }): Perf;
 //# sourceMappingURL=create-perf.d.ts.map

package/dist/perf/create-perf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-perf.d.ts","sourceRoot":"","sources":["../../src/perf/create-perf.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAc,MAAM,cAAc,CAAA;AAIpD;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,EAAE,OAAO,EAAE,EAAE;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CA0FlE"}
+{"version":3,"file":"create-perf.d.ts","sourceRoot":"","sources":["../../src/perf/create-perf.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,cAAc,CAAA;AAI9D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CAAC,EAC1B,OAAO,EACP,QAAe,GACf,EAAE;IACF,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAA;CAClB,GAAG,IAAI,CA4JP"}

package/dist/perf/index.d.ts

@@ -1,4 +1,4 @@
 export { createPerf } from './create-perf';
 export { NOOP_PERF } from './noop-perf';
-export type { Perf, PerfReport } from './perf.types';
+export type { Perf, PerfReport, PerfSnapshot, PerfSpan } from './perf.types';
 //# sourceMappingURL=index.d.ts.map

package/dist/perf/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/perf/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,YAAY,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/perf/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,YAAY,EAAE,IAAI,EAAE,UAAU,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA"}

package/dist/perf/noop-perf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"noop-perf.d.ts","sourceRoot":"","sources":["../../src/perf/noop-perf.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAA;AAExC,iFAAiF;AACjF,eAAO,MAAM,SAAS,EAAE,IAetB,CAAA"}
+{"version":3,"file":"noop-perf.d.ts","sourceRoot":"","sources":["../../src/perf/noop-perf.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAA;AAExC,iFAAiF;AACjF,eAAO,MAAM,SAAS,EAAE,IAmBtB,CAAA"}

package/dist/perf/perf.types.d.ts

@@ -10,6 +10,21 @@ export type PerfReport = Record<string, {
     avgMs: number;
     count?: number;
 }>;
+/** One span a perf measured, on the clock of its realm (ms since that realm's `timeOrigin`). */
+export type PerfSpan = {
+    name: string;
+    startTime: number;
+    duration: number;
+};
+/**
+ * What a perf hands to another realm: its spans on its own clock, the realm's `timeOrigin` to shift
+ * them by, and its tallies (`time` and `count` names), keyed like `report()`. Plain data.
+ */
+export type PerfSnapshot = {
+    timeOrigin: number;
+    spans: PerfSpan[];
+    totals: PerfReport;
+};
 /**
  * Dev-only perf helper built on the platform User Timing API
  * (`performance.mark`/`measure`). Spans live on the standard `performance`
@@ -21,14 +36,24 @@ export type PerfReport = Record<string, {
  * `createPerf` prepends the fixed `dialecte::` root.
  */
 export type Perf = {
-    /** Open a span. Name-keyed pair (like `console.time`); name = `layer::op`. */
+    /**
+     * Open a span. Name-keyed pair (like `console.time`); name = `layer::op`.
+     *
+     * @intent time a code section in dev, measure how long an operation takes
+     */
     start(name: string): void;
-    /** Close the most recent open span for `name`. Unmatched `stop` is a no-op. */
+    /**
+     * Close the most recent open span for `name`. Unmatched `stop` is a no-op.
+     *
+     * @intent end a timed section opened with start
+     */
     stop(name: string): void;
     /**
      * O(1) tally for a hot per-node primitive (e.g. store round-trips, cache
      * hits/misses) — cheaper than a span and safe in a node loop where per-call
      * `start`/`stop` would flood the timeline. Surfaced as `count` in `report()`.
+     *
+     * @intent count store reads or cache hits in dev, tally calls of a hot function cheaply
      */
     count(name: string): void;
     /**
@@ -37,15 +62,49 @@ export type Perf = {
      * `start`/`stop`). Surfaced as calls/totalMs/avgMs in `report()`. Use to time a
      * hot per-node primitive (e.g. the SAX handlers) where millions of measures
      * would flood the timeline.
+     *
+     * @intent accumulate time spent in a hot per-node function, time a callback without flooding the timeline
      */
     time<GenericResult>(name: string, fn: () => GenericResult): GenericResult;
-    /** Run `fn` inside a DevTools CPU profile (no-op in node/headless). */
+    /**
+     * Run `fn` inside a DevTools CPU profile (no-op in node/headless).
+     *
+     * @intent capture a CPU profile of an async operation in DevTools
+     */
     profile<GenericResult>(name: string, fn: () => Promise<GenericResult>): Promise<GenericResult>;
-    /** Aggregate the timeline synchronously on demand — no `PerformanceObserver`. */
+    /**
+     * Aggregate the timeline synchronously on demand — no `PerformanceObserver`.
+     *
+     * @intent read collected perf metrics, assert on store read counts in a test
+     */
     report(): PerfReport;
-    /** `console.table(report())`. */
+    /**
+     * Print the perf report as a console table (`console.table(report())`).
+     *
+     * @intent print perf metrics to the console
+     */
     log(): void;
-    /** Clear all marks + measures (bound memory between measured scenarios). */
+    /**
+     * Clear all marks + measures (bound memory between measured scenarios).
+     *
+     * @intent reset perf metrics between measured scenarios
+     */
     reset(): void;
+    /**
+     * This realm's spans (the shared timeline's; this perf's own with `timeline: false`) and this perf's tallies, to hand to another realm.
+     *
+     * @intent send a worker's or another realm's timings to the page, collect perf from the store engine
+     */
+    snapshot(): PerfSnapshot;
+    /**
+     * Fold another realm's snapshot in under `<prefix>::<name>`: its spans placed on this realm's
+     * timeline (shifted by the difference of the two `timeOrigin`s), its tallies added to this one's.
+     *
+     * @intent combine timings measured in a worker with the page's, one report across realms
+     */
+    merge(params: {
+        report: PerfSnapshot;
+        prefix: string;
+    }): void;
 };
 //# sourceMappingURL=perf.types.d.ts.map

package/dist/perf/perf.types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"perf.types.d.ts","sourceRoot":"","sources":["../../src/perf/perf.types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAC9B,MAAM,EACN;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CACjE,CAAA;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,IAAI,GAAG;IAClB,8EAA8E;IAC9E,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,+EAA+E;IAC/E,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB;;;;OAIG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB;;;;;;OAMG;IACH,IAAI,CAAC,aAAa,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,aAAa,GAAG,aAAa,CAAA;IACzE,uEAAuE;IACvE,OAAO,CAAC,aAAa,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,aAAa,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC,CAAA;IAC9F,iFAAiF;IACjF,MAAM,IAAI,UAAU,CAAA;IACpB,iCAAiC;IACjC,GAAG,IAAI,IAAI,CAAA;IACX,4EAA4E;IAC5E,KAAK,IAAI,IAAI,CAAA;CACb,CAAA"}
+{"version":3,"file":"perf.types.d.ts","sourceRoot":"","sources":["../../src/perf/perf.types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAC9B,MAAM,EACN;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CACjE,CAAA;AAED,gGAAgG;AAChG,MAAM,MAAM,QAAQ,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAA;AAE5E;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG;IAC1B,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,QAAQ,EAAE,CAAA;IACjB,MAAM,EAAE,UAAU,CAAA;CAClB,CAAA;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,IAAI,GAAG;IAClB;;;;OAIG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB;;;;OAIG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB;;;;;;OAMG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB;;;;;;;;OAQG;IACH,IAAI,CAAC,aAAa,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,aAAa,GAAG,aAAa,CAAA;IACzE;;;;OAIG;IACH,OAAO,CAAC,aAAa,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,aAAa,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC,CAAA;IAC9F;;;;OAIG;IACH,MAAM,IAAI,UAAU,CAAA;IACpB;;;;OAIG;IACH,GAAG,IAAI,IAAI,CAAA;IACX;;;;OAIG;IACH,KAAK,IAAI,IAAI,CAAA;IACb;;;;OAIG;IACH,QAAQ,IAAI,YAAY,CAAA;IACxB;;;;;OAKG;IACH,KAAK,CAAC,MAAM,EAAE;QAAE,MAAM,EAAE,YAAY,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;CAC7D,CAAA"}

package/dist/project/index.d.ts

@@ -1,10 +1,13 @@
 export { Project } from './project';
 export { buildDocumentState, reconcileDocumentState } from './state/document-state';
-export { exportDocument } from './io/export-document';
 export { exportBlob } from './io/export-blob';
 export { initEmptyDocument } from './io/init-empty-document';
-export { importDocument } from './io/import-document';
+export { runImport } from './io/run-import';
+export { runExport } from './io/run-export';
 export { resolveStore } from '../store/resolve-store';
-export type { ProjectParams, InitEmptyDocumentOptions, ImportDocumentOptions, ExportDocumentOptions, ExportBlobOptions, StorageParam, DocumentRecord, DocumentEntry, ProjectState, ProjectChannelMessage, } from './types';
-export type { InitEmptyDocumentParams, InitEmptyDocumentResult, ImportDocumentParams, ImportDocumentResult, ExportDocumentParams, ExportDocumentResult, ExportBlobParams, ExportBlobResult, } from './types';
+export type { ProjectParams, InitEmptyDocumentOptions, ImportDocumentOptions, ImportedDocument, ImportEntry, ProjectExportParams, ProjectExportResult, ProjectExportResultMaybeDocument, ProjectExportResultWithDocument, ProjectExportBlobParams, StorageParam, DocumentRecord, DocumentStatus, DocumentUpdates, ImportFilesOptions, DocumentEntry, ProjectState, ProjectChannelMessage, ProjectChannelResync, ProjectChannelEvent, } from './types';
+export type { InitEmptyDocumentParams, InitEmptyDocumentResult, ExportBlobParams, ExportBlobResult, } from './types';
+export type { RunImportParams } from './io/run-import.types';
+export type { StoreRuntime } from './io/store-runtime.types';
+export type { RunExportParams } from './io/run-export.types';
 //# sourceMappingURL=index.d.ts.map

package/dist/project/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/project/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACnC,OAAO,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAA;AACnF,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAA;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;AACrD,YAAY,EACX,aAAa,EACb,wBAAwB,EACxB,qBAAqB,EACrB,qBAAqB,EACrB,iBAAiB,EACjB,YAAY,EACZ,cAAc,EACd,aAAa,EACb,YAAY,EACZ,qBAAqB,GACrB,MAAM,SAAS,CAAA;AAChB,YAAY,EACX,uBAAuB,EACvB,uBAAuB,EACvB,oBAAoB,EACpB,oBAAoB,EACpB,oBAAoB,EACpB,oBAAoB,EACpB,gBAAgB,EAChB,gBAAgB,GAChB,MAAM,SAAS,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/project/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACnC,OAAO,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAA;AACnF,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAA;AAC5D,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;AACrD,YAAY,EACX,aAAa,EACb,wBAAwB,EACxB,qBAAqB,EACrB,gBAAgB,EAChB,WAAW,EACX,mBAAmB,EACnB,mBAAmB,EACnB,gCAAgC,EAChC,+BAA+B,EAC/B,uBAAuB,EACvB,YAAY,EACZ,cAAc,EACd,cAAc,EACd,eAAe,EACf,kBAAkB,EAClB,aAAa,EACb,YAAY,EACZ,qBAAqB,EACrB,oBAAoB,EACpB,mBAAmB,GACnB,MAAM,SAAS,CAAA;AAChB,YAAY,EACX,uBAAuB,EACvB,uBAAuB,EACvB,gBAAgB,EAChB,gBAAgB,GAChB,MAAM,SAAS,CAAA;AAChB,YAAY,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAC5D,YAAY,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAC5D,YAAY,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA"}

package/dist/project/io/export-blob.d.ts

@@ -1,7 +1,10 @@
 import { ExportBlobParams, ExportBlobResult } from '../types';
 /**
- * Export a blob from the project store. Optionally triggers a browser download
- * via `saveToDisk` (mirrors `exportDocument`'s `withDownload` option).
+ * Export a blob from the project store, and save it when asked: under another filename the save dialog is opened
+ * first, while the user's gesture still counts; under the blob's own name, once the blob is read (its name is known
+ * then).
+ *
+ * @internal the store-level step behind `project.exportBlob`; callers use the project
  */
 export declare function exportBlob(params: ExportBlobParams): Promise<ExportBlobResult>;
 //# sourceMappingURL=export-blob.d.ts.map

package/dist/project/io/export-blob.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"export-blob.d.ts","sourceRoot":"","sources":["../../../src/project/io/export-blob.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAElE;;;GAGG;AACH,wBAAsB,UAAU,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAiBpF"}
+{"version":3,"file":"export-blob.d.ts","sourceRoot":"","sources":["../../../src/project/io/export-blob.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAElE;;;;;;GAMG;AACH,wBAAsB,UAAU,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAiBpF"}

package/dist/project/io/export-document.d.ts

@@ -1,7 +1,8 @@
-import { ExportDocumentParams, ExportDocumentResult } from '../types';
+import { ExportDocumentParams, ProjectExportResultMaybeDocument } from '../types';
 /**
- * Export a document as an XMLDocument built from stored records.
- * Pure orchestration - no class state mutation.
+ * Export a document through the store: its file in the layout asked and, on the page, its DOM (parsed from a
+ * compact export) and its save (a formatted export). The save target is asked first, while the user's gesture
+ * still counts; a store export is made once more when an option needs the other layout.
  */
-export declare function exportDocument(params: ExportDocumentParams): Promise<ExportDocumentResult>;
+export declare function exportDocument(params: ExportDocumentParams): Promise<ProjectExportResultMaybeDocument>;
 //# sourceMappingURL=export-document.d.ts.map

package/dist/project/io/export-document.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"export-document.d.ts","sourceRoot":"","sources":["../../../src/project/io/export-document.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAE1E;;;GAGG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CA8BhG"}
+{"version":3,"file":"export-document.d.ts","sourceRoot":"","sources":["../../../src/project/io/export-document.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAEX,oBAAoB,EAGpB,gCAAgC,EAChC,MAAM,UAAU,CAAA;AAGjB;;;;GAIG;AACH,wBAAsB,cAAc,CACnC,MAAM,EAAE,oBAAoB,GAC1B,OAAO,CAAC,gCAAgC,CAAC,CA+B3C"}

package/dist/project/io/index.d.ts

@@ -1,5 +1,5 @@
 export { exportDocument } from './export-document';
 export { exportBlob } from './export-blob';
-export { importDocument } from './import-document';
+export { runImport } from './run-import';
 export { initEmptyDocument } from './init-empty-document';
 //# sourceMappingURL=index.d.ts.map

package/dist/project/io/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/project/io/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAClD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/project/io/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAClD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AACxC,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA"}

package/dist/project/io/init-empty-document.d.ts

@@ -2,6 +2,8 @@ import { InitEmptyDocumentParams, InitEmptyDocumentResult } from '../types';
 /**
  * Build a DocumentRecord, persist it, and create a root record in the store.
  * Pure orchestration - no class state mutation.
+ *
+ * @internal the store-level step behind `project.initEmptyDocument`; callers use the project
  */
 export declare function initEmptyDocument(params: InitEmptyDocumentParams): Promise<InitEmptyDocumentResult>;
 //# sourceMappingURL=init-empty-document.d.ts.map

package/dist/project/io/init-empty-document.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"init-empty-document.d.ts","sourceRoot":"","sources":["../../../src/project/io/init-empty-document.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,uBAAuB,EAAE,uBAAuB,EAAkB,MAAM,UAAU,CAAA;AAGhG;;;GAGG;AACH,wBAAsB,iBAAiB,CACtC,MAAM,EAAE,uBAAuB,GAC7B,OAAO,CAAC,uBAAuB,CAAC,CA4ClC"}
+{"version":3,"file":"init-empty-document.d.ts","sourceRoot":"","sources":["../../../src/project/io/init-empty-document.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAEX,uBAAuB,EACvB,uBAAuB,EAEvB,MAAM,UAAU,CAAA;AAGjB;;;;;GAKG;AACH,wBAAsB,iBAAiB,CACtC,MAAM,EAAE,uBAAuB,GAC7B,OAAO,CAAC,uBAAuB,CAAC,CAwClC"}

package/dist/project/io/resolve-config.d.ts

@@ -0,0 +1,4 @@
+import { ResolveConfigParams, ResolvedConfig } from '../types';
+/** The config a document is imported or created with: the key given, or the project's default. */
+export declare function resolveConfig(params: ResolveConfigParams): ResolvedConfig;
+//# sourceMappingURL=resolve-config.d.ts.map

package/dist/project/io/resolve-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-config.d.ts","sourceRoot":"","sources":["../../../src/project/io/resolve-config.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAEnE,kGAAkG;AAClG,wBAAgB,aAAa,CAAC,MAAM,EAAE,mBAAmB,GAAG,cAAc,CAUzE"}

package/dist/project/io/run-export.d.ts

@@ -0,0 +1,19 @@
+import { RunExportParams } from './run-export.types';
+import { ExportControl, ExportFileResult } from '../../store/store.types';
+/**
+ * The export of one document, next to the data - what every store's `exportFile` runs. The records are read
+ * parent by parent, `batchSize` children per call in the order they are written (never the whole document in
+ * one call), and written as they come; each written batch becomes a part of the answered `Blob`, whose head
+ * (declaration and root start tag) is put in front at the end. A write on the document while it is exported
+ * restarts it once from the start; a second one fails it with `EXPORT_CONFLICT`. The progress listener and the
+ * abort come apart from the export's data, as a worker call carries them.
+ *
+ * @intent implement exportFile of a custom store, export a document from a store in batches
+ */
+export declare function runExport(params: RunExportParams, control?: ExportControl): Promise<ExportFileResult>;
+/** An aborted export goes no further: `EXPORT_ABORTED`. */
+export declare function throwIfExportAborted(params: {
+    signal?: AbortSignal;
+    documentId: string;
+}): void;
+//# sourceMappingURL=run-export.d.ts.map

package/dist/project/io/run-export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-export.d.ts","sourceRoot":"","sources":["../../../src/project/io/run-export.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAA0C,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAGjG,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAgB,MAAM,qBAAqB,CAAA;AAGxF;;;;;;;;;GASG;AACH,wBAAsB,SAAS,CAC9B,MAAM,EAAE,eAAe,EACvB,OAAO,GAAE,aAAkB,GACzB,OAAO,CAAC,gBAAgB,CAAC,CAmC3B;AAsMD,2DAA2D;AAC3D,wBAAgB,oBAAoB,CAAC,MAAM,EAAE;IAAE,MAAM,CAAC,EAAE,WAAW,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAO/F"}

package/dist/project/io/run-export.types.d.ts

@@ -0,0 +1,45 @@
+import { StoreRuntime } from './store-runtime.types';
+import { Perf } from '../../perf';
+import { ExportControl, ExportFileOptions, ExportSource } from '../../store/store.types';
+import { AnyRawRecord } from '../../types';
+import { XmlWriter } from '../../xml/build/xml-writer';
+export type RunExportParams = {
+    /** The store the records are read from */
+    source: ExportSource;
+    /** The dialecte's configs (and perf): what the document is written with */
+    runtime: StoreRuntime;
+    documentId: string;
+    options?: ExportFileOptions;
+};
+/** One pass over the document: written whole, or the document changed under it (`moved`). */
+export type ExportAttempt = {
+    status: 'written';
+    file: Blob;
+} | {
+    status: 'moved';
+};
+/** An element being written: its children in the order they are written, read `batchSize` at a time. */
+export type ExportFrame = {
+    record: AnyRawRecord;
+    childRefs: AnyRawRecord['children'];
+    /** The next child to write */
+    next: number;
+    /** The children read last, from `chunkStart`; `undefined` where a child id has no record */
+    chunk: (AnyRawRecord | undefined)[];
+    chunkStart: number;
+};
+/** What one pass over a document holds while it writes it. */
+export type ExportPass = {
+    source: ExportSource;
+    documentId: string;
+    /** The document's version when the pass began */
+    version: number;
+    totalRecords: number;
+    control: ExportControl;
+    perf: Perf;
+    writer: XmlWriter;
+    /** The written batches, each a part of the file */
+    parts: Blob[];
+    recordsWritten: number;
+};
+//# sourceMappingURL=run-export.types.d.ts.map

package/dist/project/io/run-export.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-export.types.d.ts","sourceRoot":"","sources":["../../../src/project/io/run-export.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AACzD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAClC,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AACzF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAC3C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAA;AAEvD,MAAM,MAAM,eAAe,GAAG;IAC7B,0CAA0C;IAC1C,MAAM,EAAE,YAAY,CAAA;IACpB,2EAA2E;IAC3E,OAAO,EAAE,YAAY,CAAA;IACrB,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,CAAC,EAAE,iBAAiB,CAAA;CAC3B,CAAA;AAED,6FAA6F;AAC7F,MAAM,MAAM,aAAa,GAAG;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,IAAI,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,OAAO,CAAA;CAAE,CAAA;AAEnF,wGAAwG;AACxG,MAAM,MAAM,WAAW,GAAG;IACzB,MAAM,EAAE,YAAY,CAAA;IACpB,SAAS,EAAE,YAAY,CAAC,UAAU,CAAC,CAAA;IACnC,8BAA8B;IAC9B,IAAI,EAAE,MAAM,CAAA;IACZ,4FAA4F;IAC5F,KAAK,EAAE,CAAC,YAAY,GAAG,SAAS,CAAC,EAAE,CAAA;IACnC,UAAU,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,8DAA8D;AAC9D,MAAM,MAAM,UAAU,GAAG;IACxB,MAAM,EAAE,YAAY,CAAA;IACpB,UAAU,EAAE,MAAM,CAAA;IAClB,iDAAiD;IACjD,OAAO,EAAE,MAAM,CAAA;IACf,YAAY,EAAE,MAAM,CAAA;IACpB,OAAO,EAAE,aAAa,CAAA;IACtB,IAAI,EAAE,IAAI,CAAA;IACV,MAAM,EAAE,SAAS,CAAA;IACjB,mDAAmD;IACnD,KAAK,EAAE,IAAI,EAAE,CAAA;IACb,cAAc,EAAE,MAAM,CAAA;CACtB,CAAA"}

package/dist/project/io/run-import.d.ts

@@ -0,0 +1,15 @@
+import { RunImportParams } from './run-import.types';
+import { ImportControl, ImportFileResult } from '../../store/store.types';
+/**
+ * The import of one file, next to the data - what every store's `importFile` runs. It registers the
+ * document `importing` under the caller's `writeId`, parses the file with the dialecte's import
+ * session and stores it batch by batch, applies the session's writes, marks the document `ready`.
+ * A document is whole or absent: whatever fails, or an abort, removes it and is thrown (a foreign
+ * error as `IMPORT_FAILED`, its cause kept; diagnostics that are not plain JSON as
+ * `STORE_VALUE_NOT_JSON`). The progress listener and the abort come apart from the import's data, as
+ * a worker call carries them.
+ *
+ * @intent implement importFile of a custom store, import a file into a store with core's import pipeline
+ */
+export declare function runImport(params: RunImportParams, control?: ImportControl): Promise<ImportFileResult>;
+//# sourceMappingURL=run-import.d.ts.map

package/dist/project/io/run-import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-import.d.ts","sourceRoot":"","sources":["../../../src/project/io/run-import.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAGzD,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AAG1E;;;;;;;;;;GAUG;AACH,wBAAsB,SAAS,CAC9B,MAAM,EAAE,eAAe,EACvB,OAAO,GAAE,aAAkB,GACzB,OAAO,CAAC,gBAAgB,CAAC,CAqC3B"}

package/dist/project/io/run-import.types.d.ts

@@ -0,0 +1,19 @@
+import { StoreRuntime } from './store-runtime.types';
+import { Perf } from '../../perf';
+import { ImportTarget, ImportFileOptions } from '../../store/store.types';
+export type RunImportParams = {
+    /** The store the records are written to */
+    store: ImportTarget;
+    runtime: StoreRuntime;
+    file: File;
+    options?: ImportFileOptions;
+    /** The caller's id for this import, kept on the document's registry row */
+    writeId: string;
+    /**
+     * The perf the import's stages are timed on, when the store times its own stages on it too (its
+     * target's writes); one is made from `runtime.perf` when absent. The result carries its snapshot
+     * when `runtime.perf` is on.
+     */
+    perf?: Perf;
+};
+//# sourceMappingURL=run-import.types.d.ts.map

package/dist/project/io/run-import.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-import.types.d.ts","sourceRoot":"","sources":["../../../src/project/io/run-import.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AACzD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAClC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AACvD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AAE5D,MAAM,MAAM,eAAe,GAAG;IAC7B,2CAA2C;IAC3C,KAAK,EAAE,YAAY,CAAA;IACnB,OAAO,EAAE,YAAY,CAAA;IACrB,IAAI,EAAE,IAAI,CAAA;IACV,OAAO,CAAC,EAAE,iBAAiB,CAAA;IAC3B,2EAA2E;IAC3E,OAAO,EAAE,MAAM,CAAA;IACf;;;;OAIG;IACH,IAAI,CAAC,EAAE,IAAI,CAAA;CACX,CAAA"}

package/dist/project/io/store-runtime.constants.d.ts

@@ -0,0 +1,6 @@
+/** What a store built without a dialecte answers to an operation that needs one. */
+export declare const STORE_RUNTIME_REFUSALS: {
+    readonly import: "IMPORT_FAILED";
+    readonly export: "ASSERTION_FAILED";
+};
+//# sourceMappingURL=store-runtime.constants.d.ts.map

package/dist/project/io/store-runtime.constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-runtime.constants.d.ts","sourceRoot":"","sources":["../../../src/project/io/store-runtime.constants.ts"],"names":[],"mappings":"AAAA,oFAAoF;AACpF,eAAO,MAAM,sBAAsB;;;CAGzB,CAAA"}

package/dist/project/io/store-runtime.d.ts

@@ -0,0 +1,12 @@
+import { STORE_RUNTIME_REFUSALS } from './store-runtime.constants';
+import { StoreRuntime } from './store-runtime.types';
+/**
+ * The dialecte a store imports and exports with; a store built without one refuses: an import with
+ * `IMPORT_FAILED`, an export with `ASSERTION_FAILED` (it cannot write XML without the dialecte's configs).
+ */
+export declare function requireStoreRuntime(params: {
+    runtime: StoreRuntime | undefined;
+    storeName: string;
+    operation: keyof typeof STORE_RUNTIME_REFUSALS;
+}): StoreRuntime;
+//# sourceMappingURL=store-runtime.d.ts.map

package/dist/project/io/store-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-runtime.d.ts","sourceRoot":"","sources":["../../../src/project/io/store-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAA;AAIlE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAEzD;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAC3C,OAAO,EAAE,YAAY,GAAG,SAAS,CAAA;IACjC,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,OAAO,sBAAsB,CAAA;CAC9C,GAAG,YAAY,CAQf"}

package/dist/project/io/store-runtime.types.d.ts

@@ -0,0 +1,18 @@
+import { AnyDialecteConfig, DialecteHooks } from '../../types';
+/**
+ * What a store imports and exports with: the dialecte's configs and its hooks, held next to the data (a store
+ * behind a worker holds its own; a store on the page shares the project's).
+ */
+export type StoreRuntime = {
+    configs: Record<string, AnyDialecteConfig>;
+    defaultConfigKey: string;
+    /** IO hooks (`beforeImport`, `createImportSession`) and the record hooks standardization applies */
+    hooks?: DialecteHooks<AnyDialecteConfig>;
+    /** Measure the import's and the export's stages: each result then carries the run's perf snapshot */
+    perf?: boolean;
+    /** The version of the dialecte: the engine a store starts or reaches runs that version (SQLite). */
+    dialecteVersion?: string;
+    /** The address of the dialecte's engine worker, which a store running the engine apart starts (SQLite). */
+    engineUrl?: string;
+};
+//# sourceMappingURL=store-runtime.types.d.ts.map

package/dist/project/io/store-runtime.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-runtime.types.d.ts","sourceRoot":"","sources":["../../../src/project/io/store-runtime.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAE/D;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG;IAC1B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAA;IAC1C,gBAAgB,EAAE,MAAM,CAAA;IACxB,oGAAoG;IACpG,KAAK,CAAC,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAA;IACxC,qGAAqG;IACrG,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,oGAAoG;IACpG,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,2GAA2G;IAC3G,SAAS,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA"}

package/dist/project/project-channel.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The name of a project's BroadcastChannel, the public event contract (`project.channelName`): every Project of the
+ * name posts and listens there when its store announces nothing itself (IndexedDB, a custom store); a Project whose
+ * store announces its changes (SQLite, in memory) has a channel of its own (`instance`), where only its listeners hear
+ * what it reposts.
+ */
+export declare function projectChannelName(params: {
+    name: string;
+    instance?: string;
+}): string;
+//# sourceMappingURL=project-channel.d.ts.map

package/dist/project/project-channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-channel.d.ts","sourceRoot":"","sources":["../../src/project/project-channel.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAKtF"}

package/dist/project/project.constants.d.ts

@@ -0,0 +1,12 @@
+/**
+ * How long a close waits for the imports and writes in flight before it says, once, what it is waiting for: a
+ * close that never ends is a hook or a transaction callback awaiting the Project's own open, close or destroy.
+ */
+export declare const CLOSE_WAIT_REPORT_MS = 10000;
+/**
+ * The most changes a Project holds before it folds them: its own told while a call that will post them runs (past
+ * it, posted at once), and every change told while it opens (past it, its state read again once open). A call that
+ * runs on, a store written beside the Project, a long open, never hold an unbounded list.
+ */
+export declare const CHANGES_HELD_MAX = 256;
+//# sourceMappingURL=project.constants.d.ts.map

package/dist/project/project.constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.constants.d.ts","sourceRoot":"","sources":["../../src/project/project.constants.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,oBAAoB,QAAS,CAAA;AAE1C;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,MAAM,CAAA"}