@cleocode/core 2026.9.24 → 2026.9.26

package/dist/store/row-identity.d.ts

@@ -0,0 +1,480 @@
+/**
+ * Row uids (T12341): the merge key every syncing row carries.
+ *
+ * A table whose Gate A class syncs gets a `uid TEXT` column. The local primary
+ * key (`T####`, an AC id, a session id, a composite edge key) stays the local
+ * key, and local foreign keys keep pointing at it; the uid is what a merge
+ * compares, as (project, uid). Spec: `cleo docs fetch t12341-uid-scheme`.
+ *
+ * ## How a uid is made
+ *
+ * - **Minted, new row** (this build writes it): a random UUIDv7
+ *   ({@link mintRowUid}), set by the Drizzle `$defaultFn` or by the writer.
+ * - **Minted, no uid yet** (an existing row, or one an older build or a raw-SQL
+ *   writer inserted): a DETERMINISTIC v7-layout uid. Its timestamp is the
+ *   row's birth; its other 74 bits are SHA-256 over (scope, table, key, birth,
+ *   the uids of its owning rows, and, for append-only tables, a frozen content
+ *   list) ({@link mintedRowUid}). A `randomOnly` table (portable-secret) gets a
+ *   random uid instead.
+ * - **Natural** (edges, labels): a UUIDv8 over the key with every reference
+ *   replaced by the referenced row's uid ({@link naturalRowUid}); a pure
+ *   function of the row. Symmetric relation types hash their endpoints in
+ *   sorted order; the reversed twin of a symmetric edge stored both ways takes
+ *   the `natural-mirror` recipe. A reference whose row does not exist hashes
+ *   `dangling:<raw key>` and is reported.
+ *
+ * Deterministic identity can coincide for different rows (the same `T100`
+ * with the same `created_at` in two stores). Every minted row therefore also
+ * carries a birth fingerprint ({@link birthFingerprint}, `birth_fp`), hashed
+ * once from creation facts no edit changes. Same uid and same `birth_fp` is
+ * the same row; same uid and a different `birth_fp` is a COLLISION
+ * ({@link classifyUidMatch}), which the merge never merges.
+ *
+ * ## When uids are filled
+ *
+ * {@link prepareRowIdentity} runs on every open of a `cleo.db`, inside the
+ * cold-open lease right after the migrations:
+ *
+ * 1. re-asserts the identity columns and indexes (idempotent; heals a
+ *    migration the journal probe stamped without running its index DDL);
+ * 2. registers the deterministic SQL functions on the connection, re-links
+ *    acceptance criteria an older build recreated without their uid (the AC
+ *    uid graveyard, spec §6.5), then fills every NULL uid (minted tables,
+ *    owners first; then natural tables), the stored reference facts (`ac_uid`,
+ *    `ac_text_hash`) and the birth fingerprints, in one savepoint;
+ * 3. installs one TEMP `AFTER INSERT` trigger per declared table on this
+ *    connection, so a row inserted here without them gets the same values the
+ *    open pass would give it, in the same statement. A trigger never fails the
+ *    insert: a value that would clash is left NULL and reported at the next
+ *    open.
+ *
+ * A row an older build inserts keeps NULL values until the next open by this
+ * build: there is no persistent trigger that computes them (see the
+ * migration's header). Row uids are OPT-IN: nothing here runs unless
+ * `CLEO_ROW_UID_FILL=1` ({@link rowUidFillEnabled}).
+ *
+ * A failure never fails the open: it is logged, and the rows keep NULL values
+ * until a later open succeeds. A uid's timestamp is ordering sugar only: HLC
+ * (T12342) never reads time from a uid.
+ *
+ * @module
+ * @task T12341
+ * @epic T12323
+ */
+import type { DatabaseSync } from 'node:sqlite';
+import type { TableScope } from '@cleocode/contracts';
+import { BIRTH_FP_COLUMN, ROW_IDENTITY, rowIdentityColumns, rowIdentitySpec, UID_COLUMN } from './row-identity-registry.js';
+export { BIRTH_FP_COLUMN, ROW_IDENTITY, rowIdentityColumns, rowIdentitySpec, UID_COLUMN };
+/** Domain separator hashed into every deterministic uid. Changing it re-keys every row. */
+export declare const ROW_UID_DOMAIN = "cleo/row-uid/v1";
+/** Domain separator hashed into every birth fingerprint. */
+export declare const ROW_BIRTH_DOMAIN = "cleo/row-birth/v1";
+/** Per-connection SQL function computing a deterministic uid. */
+export declare const ROW_UID_SQL_FUNCTION = "cleo_row_uid";
+/** Per-connection SQL function computing a birth fingerprint. */
+export declare const ROW_BIRTH_FP_SQL_FUNCTION = "cleo_row_birth_fp";
+/** Per-connection SQL function returning a fresh random UUIDv7 (`randomOnly` tables). */
+export declare const ROW_RANDOM_UID_SQL_FUNCTION = "cleo_row_random_uid";
+/** Per-connection SQL function hashing AC text like `acTextHash`. */
+export declare const AC_TEXT_HASH_SQL_FUNCTION = "cleo_ac_text_hash";
+/** Physical name of the AC uid graveyard (spec §6.5). */
+export declare const AC_UID_GRAVEYARD = "tasks_ac_uid_graveyard";
+/**
+ * The literal-table writes the open pass makes, supplied by the tasks
+ * chokepoint (`store/sqlite-data-accessor.ts`, which registers them when it
+ * loads) so they stay enumerable by gate 28.
+ */
+export interface RowIdentityWriters {
+    relinkAcUidNative(db: DatabaseSync, acId: string, uid: string, birthFp: string | null): number;
+    clearAcUidGraveyardNative(db: DatabaseSync): void;
+    writeRowIdentityMetaNative(db: DatabaseSync, key: string, value: string): void;
+    fillIdentityColumnNative(db: DatabaseSync, table: string, column: string, valueSql: string, rowid?: number): number;
+    clearBirthFpNative(db: DatabaseSync, table: string, rowid: number): void;
+}
+/**
+ * Register the chokepoint's row-identity writers (called once by
+ * `store/sqlite-data-accessor.ts` at load).
+ *
+ * @param writers - The writers.
+ */
+export declare function registerRowIdentityWriters(writers: RowIdentityWriters): void;
+/** A SQL value as node:sqlite passes it to a function. */
+export type UidInput = string | number | bigint | Uint8Array | null;
+/**
+ * Unambiguous encoding of uid inputs: per value a type tag (0 null, 1 text,
+ * 2 integer, 3 real, 4 blob), a big-endian u32 byte length, and the bytes. An
+ * integer-valued number is tag 2 (SQLite `3` and `3.0` encode alike); any other
+ * number is tag 3 with its ECMAScript shortest round-trip text. Frozen for
+ * recipe v1.
+ *
+ * @param values - Inputs in hash order.
+ * @returns The encoded bytes.
+ */
+export declare function encodeUidInputs(values: readonly UidInput[]): Buffer;
+/**
+ * Epoch milliseconds of a stored timestamp, or `null` when absent or not a
+ * strict ISO-8601 / SQLite timestamp. A value WITHOUT a zone is UTC:
+ * `datetime('now')` writes `YYYY-MM-DD HH:MM:SS` meaning UTC, and a zoneless
+ * `YYYY-MM-DDTHH:MM:SS` is read the same way, never as the device's local
+ * time (`Date.parse` would, and a uid would then depend on the device's
+ * timezone). Anything else (`Date.parse` extensions such as `Sep 24 2026`,
+ * out-of-range fields) is `null`, i.e. an unparseable birth. Comparing that
+ * text against ISO text is wrong within a day (`' '` sorts before `'T'`), so
+ * every comparison and every uid birth goes through this function (T12329).
+ *
+ * @param value - Stored timestamp.
+ * @returns Epoch milliseconds, or `null`.
+ */
+export declare function parseStoreTimestamp(value: UidInput | undefined): number | null;
+/**
+ * A new uid for a row this build creates: a random UUIDv7.
+ *
+ * @param birthMs - The row's own birth, for a row imported with one (an
+ *   importer must never stamp import time into an old row's uid).
+ * @returns Canonical lowercase UUID string.
+ */
+export declare function mintRowUid(birthMs?: number): string;
+/**
+ * The deterministic uid of a minted row that has none: a v7 layout whose
+ * timestamp is the row's birth and whose other 74 bits come from SHA-256 over
+ * the row's identity. An unknown birth gives timestamp 0; the row's birth
+ * fingerprint flags it (`birth:unknown`), and {@link rowIdentityFindings}
+ * lists it.
+ *
+ * @param scope - Store scope.
+ * @param table - Physical table name.
+ * @param key - Local key values.
+ * @param birth - Stored birth value (any format, or null).
+ * @param ownerUids - Uids of the owning rows.
+ * @param content - Frozen content values of an append-only row.
+ * @returns Canonical lowercase UUID string.
+ */
+export declare function mintedRowUid(scope: TableScope, table: string, key: readonly UidInput[], birth: UidInput, ownerUids?: readonly UidInput[], content?: readonly UidInput[]): string;
+/**
+ * The new uid of a minted child row when its owner is re-keyed (spec §6.4):
+ * derived from STORED identity only (the child's old uid and the owner's new
+ * uid), never from a local key or content, so every replica that computes it
+ * gets the same value whatever display ids it holds. The child's timestamp
+ * bits are kept; the other 74 bits come from SHA-256.
+ *
+ * @param scope - Store scope.
+ * @param table - Physical table of the child.
+ * @param oldChildUid - The child's uid before the re-key.
+ * @param newOwnerUid - The owner's new uid.
+ * @returns Canonical lowercase UUID string.
+ */
+export declare function rekeyedChildUid(scope: TableScope, table: string, oldChildUid: string, newOwnerUid: string): string;
+/** Recipe of a natural uid: the edge itself, or the reversed twin of a symmetric edge. */
+export type NaturalRecipe = 'natural' | 'natural-mirror';
+/**
+ * The uid of a natural row: a UUIDv8 over (scope, table, key), with every
+ * reference in the key already replaced by the referenced row's uid.
+ *
+ * @param scope - Store scope.
+ * @param table - Physical table name.
+ * @param parts - Key values, references as uids.
+ * @param recipe - `natural-mirror` for the reversed twin of a symmetric edge.
+ * @returns Canonical lowercase UUID string.
+ */
+export declare function naturalRowUid(scope: TableScope, table: string, parts: readonly UidInput[], recipe?: NaturalRecipe): string;
+/**
+ * Canonical form of a text input to a birth fingerprint: Unicode NFC, line
+ * endings as LF, surrounding whitespace trimmed. Two stores that hold the same
+ * text in different normal forms fingerprint it identically.
+ *
+ * @param text - Stored text.
+ * @returns The canonical text.
+ */
+export declare function canonicalText(text: string): string;
+/**
+ * A minted row's birth fingerprint: 128 bits of SHA-256 over the canonical
+ * birth (epoch ms when it parses, so a format-only difference fingerprints
+ * alike; a flagged token otherwise) and the table's frozen birth facts, each
+ * canonicalised ({@link canonicalText}). Computed ONCE, when the row first
+ * gets its identity, from the row as it is then; never recomputed. It is
+ * write-once and syncs with the row: a receiver stores the value it receives.
+ *
+ * @param table - Physical table name.
+ * @param birth - Stored birth value.
+ * @param facts - Birth fact values, in declared order.
+ * @returns 32 lowercase hex characters.
+ */
+export declare function birthFingerprint(table: string, birth: UidInput, facts: readonly UidInput[]): string;
+/** How two rows that carry the same uid relate. */
+export type UidMatch = 'same-row' | 'collision' | 'unknown';
+/**
+ * Classify two rows of one table that carry the same uid (merge contract,
+ * spec §6.4): equal birth fingerprints are one row; different ones are a
+ * COLLISION that must never be merged; a missing fingerprint must be filled
+ * before the row is emitted.
+ *
+ * @param a - Birth fingerprint of one row.
+ * @param b - Birth fingerprint of the other.
+ * @returns The relation.
+ */
+export declare function classifyUidMatch(a: string | null, b: string | null): UidMatch;
+/**
+ * Register the identity SQL functions on a connection: the deterministic uid
+ * and birth fingerprint, the AC text hash, and a random v7 for `randomOnly`
+ * tables.
+ *
+ * @param db - Connection on a `cleo.db`.
+ * @param scope - The store's scope.
+ */
+export declare function registerRowUidFunction(db: DatabaseSync, scope: TableScope): void;
+/**
+ * Re-assert the identity columns and indexes of every declared table present
+ * in the store. Idempotent; the migration normally created them already.
+ *
+ * @param db - Connection on a `cleo.db`.
+ * @param scope - The store's scope.
+ * @returns Statements that had to be run (empty on a healthy store).
+ */
+export declare function ensureRowIdentitySchema(db: DatabaseSync, scope: TableScope): string[];
+/** Findings the open pass reports (and `cleo doctor` can list). */
+export interface RowIdentityFindings {
+    /** Minted rows whose birth is missing or unparseable (uid timestamp 0), per table. */
+    readonly unknownBirth: Readonly<Record<string, number>>;
+    /** Natural rows with a key reference to a row that does not exist, per table. */
+    readonly danglingRefs: Readonly<Record<string, number>>;
+    /** Reversed twins of symmetric edges stored both ways (duplicates to drop), per table. */
+    readonly mirrorEdges: Readonly<Record<string, number>>;
+}
+/** What one fill pass did. */
+export interface RowUidFillReport {
+    /** Uids written per table. */
+    readonly filled: Readonly<Record<string, number>>;
+    /** Stored reference facts written, per `table.column`. */
+    readonly refsFilled: Readonly<Record<string, number>>;
+    /** Birth fingerprints written per table. */
+    readonly fingerprinted: Readonly<Record<string, number>>;
+    /** Acceptance criteria re-linked to their uid from the graveyard. */
+    readonly relinked: number;
+    /** Rows left without a uid or fingerprint, per table (a uniqueness clash). */
+    readonly unfilled: Readonly<Record<string, number>>;
+    /** Rows the recipes flag. */
+    readonly findings: RowIdentityFindings;
+    /** Schema statements the pass had to re-run. */
+    readonly healed: readonly string[];
+    /**
+     * Pre-release identity values: `none` (the recipe marker is current, or
+     * there were no values), `cleared` (values without the current recipe
+     * marker were cleared and refilled), or `refused` (they were kept because
+     * uids have already synced; spec §12.1).
+     */
+    readonly refill: 'none' | 'cleared' | 'refused';
+}
+/**
+ * Fill the NULL uids of one declared table (the open pass's recipe). Requires
+ * {@link registerRowUidFunction} on the connection. Used after a uid re-key,
+ * which clears the uids of the natural rows keyed by the re-keyed row.
+ *
+ * @param db - Connection on a `cleo.db`.
+ * @param scope - The store's scope.
+ * @param table - Declared table.
+ * @returns Uids written.
+ */
+export declare function fillTableUids(db: DatabaseSync, scope: TableScope, table: string, writers?: RowIdentityWriters): number;
+/**
+ * Rows the recipes flag: minted rows with an unknown birth (uid timestamp 0),
+ * natural rows with a dangling key reference, and reversed twins of symmetric
+ * edges stored both ways.
+ *
+ * @param db - Connection on a `cleo.db`.
+ * @param scope - The store's scope.
+ * @returns Counts per table (tables without findings are absent).
+ */
+export declare function rowIdentityFindings(db: DatabaseSync, scope: TableScope): RowIdentityFindings;
+/**
+ * Fill every NULL uid, stored reference fact and birth fingerprint of the
+ * declared tables, in one savepoint, after re-linking graveyard AC uids.
+ * Requires {@link registerRowUidFunction} on the connection. Idempotent: a
+ * filled store writes nothing.
+ *
+ * @param db - Connection on a `cleo.db`.
+ * @param scope - The store's scope.
+ * @returns What was written and what could not be.
+ */
+export declare function fillRowUids(db: DatabaseSync, scope: TableScope, writers?: RowIdentityWriters): Omit<RowUidFillReport, 'healed' | 'findings' | 'refill'>;
+/**
+ * Install the per-connection TEMP triggers that fill a uid, the stored
+ * reference facts and the birth fingerprint on insert, in that order. Each
+ * step is guarded so the trigger never fails the insert: a uid that would
+ * clash is left NULL (a symmetric edge first tries its mirror recipe).
+ * Requires {@link registerRowUidFunction}.
+ *
+ * @param db - Connection on a `cleo.db`.
+ * @param scope - The store's scope.
+ */
+export declare function installRowUidTriggers(db: DatabaseSync, scope: TableScope): void;
+/**
+ * Bring a freshly opened `cleo.db` connection's row identity up to date:
+ * schema, graveyard re-link, fill, per-connection triggers. Never throws: a
+ * failure is logged and the store opens with the values it has.
+ *
+ * @param db - Connection on a `cleo.db`, after its migrations ran.
+ * @param scope - The store's scope.
+ * @param options - `triggers: false` skips the per-connection triggers (a
+ *   dedicated migration connection: exodus refuses copies whose triggers call
+ *   an opaque function, so its rows are filled at the next open instead).
+ * @returns The fill report, or `null` when skipped or failed.
+ */
+/**
+ * Version of every identity recipe this build derives (uid, natural uid,
+ * birth fingerprint, encoding). Written to {@link ROW_IDENTITY_META_TABLE} under
+ * {@link ROW_IDENTITY_RECIPE_KEY} by the first fill; bumped by any change to a
+ * recipe, a frozen content or birth-fact list, or the encoding.
+ */
+export declare const ROW_IDENTITY_RECIPE = "cleo/row-identity/v2";
+/**
+ * The recipe 9.25 shipped (v1). v2 changed only the birth facts of AC history
+ * and evidence bindings (@refFp:ac_uid and ac_text_hash → none / ac_id,
+ * T12802); a store filled
+ * with v1 has those two tables' fingerprints re-derived (see
+ * {@link v1ReleaseBirthFp}).
+ */
+export declare const ROW_IDENTITY_RECIPE_V1 = "cleo/row-identity/v1";
+/**
+ * The v1 fingerprint of an AC-history or binding row, to recognise a value
+ * the 9.25 recipe derived: v1 hashed the criterion's fingerprint
+ * (`@refFp:ac_uid`), or `ref:none` / `ref:missing`. Other tables: `null`
+ * (their v1 and v2 recipes are the same).
+ *
+ * @param db - Connection on the project `cleo.db`.
+ * @param table - Declared minted table.
+ * @param row - The stored row.
+ * @returns The v1 value, or `null`.
+ * @task T12802
+ */
+export declare function v1ReleaseBirthFp(db: DatabaseSync, table: string, row: Readonly<Record<string, UidInput>>): string | null;
+/**
+ * Local-only key/value table of the row-identity layer. Not
+ * `tasks_schema_meta`: the twin collapse drops twin-only keys of that table on
+ * its first run (T12535), which would lose the marker.
+ */
+export declare const ROW_IDENTITY_META_TABLE = "tasks_row_identity_meta";
+/** Key holding the recipe version the store's identity values were derived with. */
+export declare const ROW_IDENTITY_RECIPE_KEY = "row_identity_recipe";
+/**
+ * Key the sync layer (T12342/T12343) writes BEFORE the
+ * first uid leaves the device. Once present, identity values are shared and
+ * are never cleared locally.
+ */
+export declare const ROW_IDENTITY_SYNCED_KEY = "row_identity_synced";
+/**
+ * Re-create the tables, trigger and columns the uid migration adds when they
+ * are missing: a store the journal probe stamped as migrated after only its
+ * ADD COLUMNs had run (Scenario 3, Case A) otherwise never gets them.
+ * Idempotent.
+ *
+ * @param db - Connection on the project `cleo.db`.
+ * @returns Statements that had to be run.
+ */
+export declare function ensureIdentityTables(db: DatabaseSync): string[];
+/**
+ * The birth fingerprint the pre-release v4/v5 build derived (the recipe that
+ * reached live cleocode on 2026-09-28): raw birth text, raw facts, the task
+ * title from the earliest `task_created` audit event, and an AC's OWNER UID
+ * instead of its owner's fingerprint. Used only to recognise those values.
+ *
+ * @param db - Connection on the project `cleo.db`.
+ * @param table - Minted table.
+ * @param row - The stored row.
+ * @returns The pre-release fingerprint, or `null` when the table had none.
+ */
+export declare function preReleaseBirthFp(db: DatabaseSync, table: string, row: Readonly<Record<string, UidInput>>): string | null;
+/**
+ * Record that the store's identity values follow {@link ROW_IDENTITY_RECIPE}.
+ * The fill writes it; {@link markRowIdentityShared} writes it too on the
+ * first receive (a device that pulls before it ever fills).
+ *
+ * @param db - Connection on the project `cleo.db`.
+ */
+export declare function writeRecipeMarker(db: DatabaseSync, writers?: RowIdentityWriters): void;
+/**
+ * Whether the store's identity values are shared with other devices
+ * ({@link ROW_IDENTITY_SYNCED_KEY} present): from then on no local write may
+ * clear or re-point a uid.
+ *
+ * @param db - Connection on the project `cleo.db`.
+ * @returns True once identity has been sent or received.
+ * @task T12806
+ */
+export declare function rowIdentityShared(db: DatabaseSync): boolean;
+/**
+ * Record that identity values are now SHARED with other devices: the recipe
+ * marker, and {@link ROW_IDENTITY_SYNCED_KEY} (first write wins, with the
+ * direction). Called on the first receive (a pull-first clone that never
+ * filled) as well as before the first send; once present, the open pass
+ * never clears an identity value (spec §12.1).
+ *
+ * @param db - Connection on the project `cleo.db`.
+ * @param direction - `receive` (the merge applied a row or op) or `send`.
+ * @param writers - The chokepoint writers.
+ * @task T12746
+ */
+export declare function markRowIdentityShared(db: DatabaseSync, direction: 'send' | 'receive', writers?: RowIdentityWriters): void;
+/**
+ * Re-create the row-identity SCHEMA a store should have, on every open,
+ * whatever the fill flag (T12878). DDL only: the identity tables, the
+ * graveyard trigger, the columns an early table lacks, the uid columns and
+ * their indexes. No row value is read or written. A store whose uid migration
+ * was journaled without running its statements (journal Scenario 3 Case A:
+ * live cleocode under 9.25, spec §12.2) gets the full schema here; the fill,
+ * refill and TEMP triggers stay opt-in ({@link prepareRowIdentity}).
+ *
+ * Never throws: a failure is logged and the open continues.
+ *
+ * @param db - Connection on a `cleo.db`, inside the cold-open lease.
+ * @param scope - The store's scope.
+ * @returns The DDL statements it ran (empty when the schema was complete).
+ * @task T12878
+ */
+export declare function healRowIdentitySchema(db: DatabaseSync, scope: TableScope, writers?: RowIdentityWriters | undefined): string[];
+/**
+ * Meta key of the heal receipt: when the open last re-created missing
+ * identity schema, and what (T12878). Local-only bookkeeping of the heal
+ * itself, in `tasks_row_identity_meta`; no row value of any other table is
+ * written. `cleo doctor` (the `row_identity` check) shows it.
+ */
+export declare const ROW_IDENTITY_HEAL_KEY = "row_identity_schema_healed";
+/** The receipt {@link healRowIdentitySchema} leaves when it re-created schema. */
+export interface RowIdentityHealReceipt {
+    readonly at: string;
+    readonly scope?: TableScope;
+    readonly statements: number;
+    /** Objects re-created or columns added (table, index, trigger or `table.column`). */
+    readonly objects: readonly string[];
+}
+/**
+ * The last heal receipt of a store, read-only (`undefined` when the schema
+ * never needed healing).
+ *
+ * @param db - Connection on a project `cleo.db` (read-only is fine).
+ * @returns The receipt.
+ * @task T12878
+ */
+export declare function readRowIdentityHealReceipt(db: DatabaseSync): RowIdentityHealReceipt | undefined;
+/**
+ * Every heal receipt a store kept, oldest first (read-only).
+ *
+ * @param db - Connection on a project `cleo.db` (read-only is fine).
+ * @returns The receipts (empty when the schema never needed healing).
+ * @task T12878
+ */
+export declare function readRowIdentityHealHistory(db: DatabaseSync): RowIdentityHealReceipt[];
+/**
+ * Identity schema a project store lacks, read-only: missing identity tables,
+ * the graveyard trigger, and the alias / graveyard columns an early table
+ * lacks (T12878; the open heals them).
+ *
+ * @param db - Connection on a project `cleo.db` (read-only is fine).
+ * @returns What is missing (empty when complete).
+ * @task T12878
+ */
+export declare function missingRowIdentitySchema(db: DatabaseSync): string[];
+export declare function prepareRowIdentity(db: DatabaseSync, scope: TableScope, options?: {
+    readonly triggers?: boolean;
+    readonly writers?: RowIdentityWriters;
+}): RowUidFillReport | null;
+//# sourceMappingURL=row-identity.d.ts.map

package/dist/store/row-identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"row-identity.d.ts","sourceRoot":"","sources":["../../src/store/row-identity.ts"],"names":[],"mappings":"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"}