@chipmobilesdk/rn-notification 0.6.0 → 0.7.0

package/lib/typescript/commonjs/schedule/partition.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Owner-tag and group-tag partitioning.
+ *
+ * A tag is an opaque label the caller supplies and the package never
+ * interprets. That is deliberate: modelling identity would mean acquiring an
+ * opinion about it, and this package is forbidden from knowing anything about
+ * accounts, tenants, or users.
+ *
+ * What the tag buys is one call — "clear this account's notifications" — on a
+ * shared device, without the package ever learning what an account is.
+ */
+import type { PendingEntry } from '../contract/notification';
+export type PartitionKind = 'owner' | 'group';
+/** Selects entries carrying a tag. Comparison is exact; nothing is normalized. */
+export declare function selectByTag(entries: readonly PendingEntry[], kind: PartitionKind, tag: string): readonly PendingEntry[];
+/** Identifiers to cancel for a tag. */
+export declare function idsForTag(entries: readonly PendingEntry[], kind: PartitionKind, tag: string): readonly string[];
+/**
+ * Groups entries by a tag, keeping untagged entries under a distinct bucket.
+ *
+ * Untagged is not the same as any tag: an entry with no owner belongs to no
+ * account, and folding it into one would make a sign-out delete notifications
+ * that were never that account's.
+ */
+export declare function partition(entries: readonly PendingEntry[], kind: PartitionKind): {
+    readonly tagged: ReadonlyMap<string, readonly PendingEntry[]>;
+    readonly untagged: readonly PendingEntry[];
+};
+//# sourceMappingURL=partition.d.ts.map

package/lib/typescript/commonjs/schedule/partition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partition.d.ts","sourceRoot":"","sources":["../../../../src/schedule/partition.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAE7D,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,OAAO,CAAC;AAE9C,kFAAkF;AAClF,wBAAgB,WAAW,CAC1B,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,IAAI,EAAE,aAAa,EACnB,GAAG,EAAE,MAAM,GACT,SAAS,YAAY,EAAE,CAIzB;AAED,uCAAuC;AACvC,wBAAgB,SAAS,CACxB,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,IAAI,EAAE,aAAa,EACnB,GAAG,EAAE,MAAM,GACT,SAAS,MAAM,EAAE,CAEnB;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CACxB,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,IAAI,EAAE,aAAa,GACjB;IACF,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,CAAC,CAAC;IAC9D,QAAQ,CAAC,QAAQ,EAAE,SAAS,YAAY,EAAE,CAAC;CAC3C,CAmBA"}

package/lib/typescript/commonjs/schedule/resolve-moment.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Delivery moment resolution.
+ *
+ * Two rules, and they are two sides of one decision rather than a threshold:
+ * a moment more than the tolerance in the past is a caller error and is
+ * refused; a moment a few seconds in the past is a processing delay and is
+ * delivered promptly. Both outcomes are reported, so a caller never has to
+ * guess which happened.
+ *
+ * Sixty seconds is long enough to absorb reconciling a large desired set, cold
+ * start work, and clock skew, and short enough that a genuinely stale schedule
+ * is still caught rather than fired at the user minutes late with no
+ * explanation.
+ */
+import type { DeliveryMoment } from '../contract/notification';
+export declare const PAST_TOLERANCE_MS = 60000;
+export type MomentResolution = {
+    readonly kind: 'future';
+    readonly at: number;
+} | {
+    readonly kind: 'immediate';
+    readonly at: number;
+    readonly lateBy: number;
+};
+/**
+ * Classifies a resolved instant against now.
+ *
+ * Takes an already-anchored instant: anchoring decides *which* instant a moment
+ * means, and this decides whether that instant is usable. Keeping them separate
+ * is what lets each be tested without the other.
+ */
+export declare function resolveMoment(resolvedAt: number, now: number): MomentResolution;
+/** Validates the shape of a caller-supplied moment before anchoring resolves it. */
+export declare function validateMoment(moment: DeliveryMoment): void;
+//# sourceMappingURL=resolve-moment.d.ts.map

package/lib/typescript/commonjs/schedule/resolve-moment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-moment.d.ts","sourceRoot":"","sources":["../../../../src/schedule/resolve-moment.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE/D,eAAO,MAAM,iBAAiB,QAAS,CAAC;AAExC,MAAM,MAAM,gBAAgB,GACzB;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAChD;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEhF;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,gBAAgB,CAyB/E;AAED,oFAAoF;AACpF,wBAAgB,cAAc,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,CAoB3D"}

package/lib/typescript/commonjs/schedule/validate-content.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Content validation.
+ *
+ * The package passes content through **unchanged** and never truncates it.
+ * Display truncation is the platform's decision and differs between them; a
+ * library that pre-truncated would be guessing at a rule it does not own, and
+ * would corrupt content that would have displayed fine.
+ *
+ * What it does refuse is content over the platform's hard payload limit, where
+ * the alternative is not a shortened notification but a failed or undefined
+ * delivery. That is a real error and is reported as one, before any platform
+ * call.
+ */
+import type { NotificationContent } from '../contract/notification';
+/**
+ * Hard payload ceilings.
+ *
+ * These are *not* display limits. A title longer than a phone shows is fine and
+ * is passed through; the README documents where each platform visually
+ * truncates so a caller can decide for itself.
+ *
+ * The total is deliberately lower than the sum of the parts, so it actually
+ * binds — a per-field check that can never be exceeded in aggregate would be
+ * dead code. It sits under the 4 KB payload budget both platforms enforce,
+ * leaving headroom for the routing payload that shares it.
+ */
+export declare const CONTENT_LIMITS: {
+    readonly maxTitleBytes: 512;
+    readonly maxBodyBytes: 3072;
+    readonly maxSubtitleBytes: 512;
+    readonly maxTotalBytes: 3584;
+};
+/** UTF-8 byte length — the unit the platforms actually bound. */
+export declare function byteLength(value: string): number;
+/**
+ * Validates content and returns it **byte-identical**.
+ *
+ * The return value is the same object reference where possible, so nothing
+ * downstream can mistake this for a transformation step.
+ */
+export declare function validateContent(content: NotificationContent): NotificationContent;
+//# sourceMappingURL=validate-content.d.ts.map

package/lib/typescript/commonjs/schedule/validate-content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-content.d.ts","sourceRoot":"","sources":["../../../../src/schedule/validate-content.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAEpE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc;;;;;CAKjB,CAAC;AAEX,iEAAiE;AACjE,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAUhD;AAaD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,mBAAmB,GAAG,mBAAmB,CA4CjF"}

package/lib/typescript/commonjs/schedule/validate-identifier.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Identifier validation.
+ *
+ * Identity is the caller's contract: only the caller can derive an identifier
+ * reproducibly from its own data, so the package never generates one.
+ *
+ * The charset is composite-friendly because real derived keys are hierarchical
+ * — `task:1234:reminder:2`. A charset that forced encoding of natural keys
+ * would work against caller-supplied identity being readable and reproducible,
+ * which is most of its value.
+ *
+ * Nothing is normalized, trimmed, case-folded, or hashed. Two identifiers
+ * differing in any character are different identifiers, and the value visible
+ * at the platform boundary is exactly what the caller supplied — which is what
+ * lets a notification be traced back to the data that produced it.
+ */
+export declare const MAX_IDENTIFIER_LENGTH = 128;
+export type IdentifierKind = 'id' | 'ownerTag' | 'groupTag' | 'seriesId' | 'actionId';
+/**
+ * Throws a typed error naming the violated rule.
+ *
+ * The offending character and its position are reported; the value itself never
+ * is, because an identifier can carry user data a caller derived it from.
+ */
+export declare function validateIdentifier(value: unknown, kind?: IdentifierKind): string;
+/** Non-throwing form, for validating a batch without unwinding on the first failure. */
+export declare function isValidIdentifier(value: unknown): value is string;
+/** Validates an optional tag, returning undefined when absent rather than failing. */
+export declare function validateOptionalTag(value: string | undefined, kind: Extract<IdentifierKind, 'ownerTag' | 'groupTag'>): string | undefined;
+//# sourceMappingURL=validate-identifier.d.ts.map

package/lib/typescript/commonjs/schedule/validate-identifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-identifier.d.ts","sourceRoot":"","sources":["../../../../src/schedule/validate-identifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAKH,eAAO,MAAM,qBAAqB,MAAM,CAAC;AAgBzC,MAAM,MAAM,cAAc,GAAG,IAAI,GAAG,UAAU,GAAG,UAAU,GAAG,UAAU,GAAG,UAAU,CAAC;AA0BtF;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,GAAE,cAAqB,GAAG,MAAM,CAsCtF;AAED,wFAAwF;AACxF,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CASjE;AAED,sFAAsF;AACtF,wBAAgB,mBAAmB,CAClC,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,IAAI,EAAE,OAAO,CAAC,cAAc,EAAE,UAAU,GAAG,UAAU,CAAC,GACpD,MAAM,GAAG,SAAS,CAGpB"}

package/lib/typescript/commonjs/schedule/writer.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The one door every consumer notification goes through to reach the engine.
+ *
+ * Scheduler, reconciler, recurrence, re-anchoring and channel re-homing all
+ * write notifications. Each used to call `engine.schedule` itself, and the
+ * guarantees attached to a write — a repeating alert gets its stop marker, and
+ * that marker moves when the notification moves — existed only on the paths
+ * that remembered them. A recurring alarm never stopped, and a re-anchored one
+ * stopped at the old instant.
+ *
+ * Validation stays with each caller, because each has its own failure policy:
+ * the scheduler throws, reconciliation rejects one entry and carries on, and
+ * recurrence validates its template once at registration.
+ */
+import type { NotificationEngineAdapter, EngineScheduleRequest } from '../engine/adapter';
+export interface ScheduleWriter {
+    /** Writes one notification and brings its stop marker in line with it. */
+    write(input: EngineScheduleRequest): Promise<void>;
+    /** Cancels one notification and the marker guarding it. */
+    cancel(id: string): Promise<void>;
+    /** Drops the marker for a notification already cancelled some other way. */
+    releaseStop(targetId: string): Promise<void>;
+    /**
+     * Platform slots consumer notifications can actually use: stop markers hold
+     * real capacity, so the usable ceiling is the platform's minus theirs.
+     */
+    capacity(): Promise<number>;
+    /**
+     * A writer for one pass of many writes (NOT-08): it reads the outstanding stop
+     * markers once and keeps that view current, instead of a full read of every
+     * pending trigger per operation.
+     */
+    pass(): ScheduleWriter;
+}
+export declare function createScheduleWriter(engine: NotificationEngineAdapter): ScheduleWriter;
+//# sourceMappingURL=writer.d.ts.map

package/lib/typescript/commonjs/schedule/writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writer.d.ts","sourceRoot":"","sources":["../../../../src/schedule/writer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,yBAAyB,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAG1F,MAAM,WAAW,cAAc;IAC9B,0EAA0E;IAC1E,KAAK,CAAC,KAAK,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACnD,2DAA2D;IAC3D,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClC,4EAA4E;IAC5E,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7C;;;OAGG;IACH,QAAQ,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAC5B;;;;OAIG;IACH,IAAI,IAAI,cAAc,CAAC;CACvB;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,yBAAyB,GAAG,cAAc,CAEtF"}

package/lib/typescript/commonjs/state/caps.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Caps and eviction for the persisted collections.
+ *
+ * No collection may grow without bound. Eviction is oldest-first and always
+ * observable — a silent eviction would turn a bounded guarantee into an
+ * unexplained one.
+ */
+/** Every persisted collection with a size or age bound. */
+export declare const COLLECTION_CAPS: {
+    readonly dedupLedger: {
+        readonly maxEntries: 500;
+        readonly retentionMs: number;
+    };
+    readonly interactionBuffer: {
+        readonly maxEntries: 50;
+        readonly retentionMs: number;
+    };
+    readonly migrationLedger: {
+        readonly maxEntries: 20;
+        readonly retentionMs: number;
+    };
+    readonly seriesLedger: {
+        readonly maxEntries: 32;
+        readonly retentionMs: number;
+    };
+    readonly permissionHistory: {
+        readonly maxEntries: 64;
+        readonly retentionMs: number;
+    };
+};
+export type CollectionName = keyof typeof COLLECTION_CAPS;
+/** Anything stored with a timestamp, which is everything that can age out. */
+export interface Timestamped {
+    readonly at: number;
+}
+export interface EvictionOutcome<T> {
+    readonly kept: readonly T[];
+    readonly evicted: readonly T[];
+    readonly reason: 'none' | 'cap' | 'retention' | 'cap+retention';
+    /** Entries kept beyond the cap because none of them may be evicted (NOT-16). */
+    readonly overCap: number;
+}
+/**
+ * Applies retention first, then the size cap.
+ *
+ * Order matters: expiring stale entries before trimming means a burst of new
+ * entries does not evict fresh ones while stale ones sit protected by
+ * recency ordering.
+ */
+export declare function evict<T extends Timestamped>(entries: readonly T[], collection: CollectionName, now: number): EvictionOutcome<T>;
+//# sourceMappingURL=caps.d.ts.map

package/lib/typescript/commonjs/state/caps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"caps.d.ts","sourceRoot":"","sources":["../../../../src/state/caps.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,2DAA2D;AAC3D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;CAMlB,CAAC;AAEX,MAAM,MAAM,cAAc,GAAG,MAAM,OAAO,eAAe,CAAC;AAE1D,8EAA8E;AAC9E,MAAM,WAAW,WAAW;IAC3B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,eAAe,CAAC,CAAC;IACjC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC,EAAE,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC,EAAE,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,GAAG,WAAW,GAAG,eAAe,CAAC;IAChE,gFAAgF;IAChF,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CACzB;AAaD;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,WAAW,EAC1C,OAAO,EAAE,SAAS,CAAC,EAAE,EACrB,UAAU,EAAE,cAAc,EAC1B,GAAG,EAAE,MAAM,GACT,eAAe,CAAC,CAAC,CAAC,CAyCpB"}

package/lib/typescript/commonjs/state/dedup-ledger.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The push deduplication ledger.
+ *
+ * Providers redeliver. The redelivery typically arrives in a **fresh process**,
+ * which is precisely why this is persisted rather than held in memory — an
+ * in-memory set would forget exactly when it matters.
+ *
+ * Bounded by cap and retention. A payload redelivered after its entry has aged
+ * out is treated as new: that is the documented bound of the guarantee, not a
+ * defect.
+ */
+import type { StateManager } from './record';
+export declare function isDuplicate(state: StateManager, dedupId: string): boolean;
+/**
+ * Records a payload as seen.
+ *
+ * Returns true when it was already known, so a caller can branch on the same
+ * read that records it rather than checking twice.
+ */
+export declare function recordSeen(state: StateManager, dedupId: string, now: number, ownerTag?: string): boolean;
+//# sourceMappingURL=dedup-ledger.d.ts.map

package/lib/typescript/commonjs/state/dedup-ledger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dedup-ledger.d.ts","sourceRoot":"","sources":["../../../../src/state/dedup-ledger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C,wBAAgB,WAAW,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAEzE;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CACzB,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,MAAM,EACX,QAAQ,CAAC,EAAE,MAAM,GACf,OAAO,CAKT"}

package/lib/typescript/commonjs/state/interaction-buffer.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The durable interaction buffer.
+ *
+ * A cold-start tap arrives before any handler exists. Holding it in memory
+ * would be enough if the process always survived — but the process is exactly
+ * what does not survive a cold start, so the buffer is persisted.
+ *
+ * This is the one content-bearing thing the package stores: an interaction
+ * cannot be delivered without its routing payload. It is evicted the moment it
+ * is delivered, and time-limited regardless, so an event nobody ever collects
+ * cannot sit on disk forever.
+ *
+ * Text the user typed into a reply action is never written to disk (NOT-14): it
+ * is free text, and the store is not encrypted. It is held in memory beside the
+ * buffer, so a handler registered later in the same process still receives it;
+ * if the process dies first, the event is delivered without `inputText`.
+ */
+import type { StateManager } from './record';
+import type { InteractionEvent } from '../contract/interaction';
+export declare function buffer(state: StateManager, event: InteractionEvent): void;
+/**
+ * Takes every buffered event in occurrence order and clears them.
+ *
+ * Draining and clearing together is deliberate: delivering an event twice is
+ * worse than the alternative, because a consumer that acts on an interaction
+ * (marking a task done, sending a reply) would act twice.
+ */
+export declare function drain(state: StateManager): readonly InteractionEvent[];
+export declare function bufferedCount(state: StateManager): number;
+//# sourceMappingURL=interaction-buffer.d.ts.map

package/lib/typescript/commonjs/state/interaction-buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interaction-buffer.d.ts","sourceRoot":"","sources":["../../../../src/state/interaction-buffer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAuB,MAAM,UAAU,CAAC;AAClE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAmBhE,wBAAgB,MAAM,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,gBAAgB,GAAG,IAAI,CAoBzE;AAED;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,YAAY,GAAG,SAAS,gBAAgB,EAAE,CAuBtE;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAEzD"}

package/lib/typescript/commonjs/state/mmkv-store.d.ts

@@ -0,0 +1,33 @@
+/**
+ * MMKV-backed state store.
+ *
+ * Every MMKV import is confined to this file, so the rest of the package stays
+ * testable without a native module.
+ *
+ * Backup exclusion is achieved by *where* the data lives rather than by setting
+ * a file attribute: on iOS the instance is rooted under `Library/Caches`, which
+ * the platform excludes from iCloud and iTunes backup by design. The OS may
+ * purge that directory under storage pressure — acceptable here precisely
+ * because discarding and rebuilding this record is already a specified,
+ * non-blocking condition.
+ *
+ * On Android, backup exclusion is declared in the consuming app's
+ * `data_extraction_rules.xml` and `full_backup_content`, documented in the
+ * README. It is the app's manifest, so it is the app's declaration to make.
+ */
+import type { StateStore } from './store';
+export interface MmkvStoreOptions {
+    /** Told once, with the reason, when the store falls back to memory. */
+    readonly onDegraded?: (cause: unknown) => void;
+}
+/**
+ * Creates the persistent store, falling back to memory when MMKV is absent.
+ *
+ * The fallback is deliberate: a missing optional native module degrades
+ * deduplication and cold-start buffering to session scope, which is a
+ * documented degradation. It must never stop notifications being delivered, and
+ * it is never silent (NOT-15): it reports `STATE_STORE_DEGRADED` to the app's SDK
+ * sinks and to `onDegraded`, and the store reports `durable: false`.
+ */
+export declare function createMmkvStore(options?: MmkvStoreOptions): StateStore;
+//# sourceMappingURL=mmkv-store.d.ts.map

package/lib/typescript/commonjs/state/mmkv-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mmkv-store.d.ts","sourceRoot":"","sources":["../../../../src/state/mmkv-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAWH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAiB1C,MAAM,WAAW,gBAAgB;IAChC,uEAAuE;IACvE,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CAC/C;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,OAAO,GAAE,gBAAqB,GAAG,UAAU,CAiC1E"}

package/lib/typescript/commonjs/state/permission-history.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Permission-request history.
+ *
+ * The platform cannot tell you whether you have already asked. On both
+ * platforms a second request after a denial is silently a no-op, so an app that
+ * does not remember will keep "asking" and keep appearing to be refused.
+ *
+ * Keyed by owner tag so a multi-account device can clear one account's history
+ * on sign-out without forgetting what it asked the others.
+ */
+import type { StateManager } from './record';
+import type { PermissionKind } from '../contract/permission';
+export declare function hasRequested(state: StateManager, kind: PermissionKind, ownerTag?: string): boolean;
+export declare function recordRequested(state: StateManager, kind: PermissionKind, now: number, ownerTag?: string): void;
+/** How many requests for `kind` the user has refused on this device. */
+export declare function denialCount(state: StateManager, kind: PermissionKind): number;
+export declare function recordDenial(state: StateManager, kind: PermissionKind, now: number): void;
+/** Forgets refusals once the permission is seen granted: the next refusal starts over. */
+export declare function clearDenials(state: StateManager, kind: PermissionKind): void;
+//# sourceMappingURL=permission-history.d.ts.map

package/lib/typescript/commonjs/state/permission-history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permission-history.d.ts","sourceRoot":"","sources":["../../../../src/state/permission-history.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAM7D,wBAAgB,YAAY,CAC3B,KAAK,EAAE,YAAY,EACnB,IAAI,EAAE,cAAc,EACpB,QAAQ,CAAC,EAAE,MAAM,GACf,OAAO,CAGT;AAED,wBAAgB,eAAe,CAC9B,KAAK,EAAE,YAAY,EACnB,IAAI,EAAE,cAAc,EACpB,GAAG,EAAE,MAAM,EACX,QAAQ,CAAC,EAAE,MAAM,GACf,IAAI,CAQN;AAKD,wEAAwE;AACxE,wBAAgB,WAAW,CAAC,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,cAAc,GAAG,MAAM,CAG7E;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,cAAc,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAOzF;AAED,0FAA0F;AAC1F,wBAAgB,YAAY,CAAC,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,cAAc,GAAG,IAAI,CAI5E"}

package/lib/typescript/commonjs/state/record.d.ts

@@ -0,0 +1,134 @@
+/**
+ * The persisted state record.
+ *
+ * Six collections, holding only what the platform will not tell us. No
+ * notification content, no push token, no desired set. The interaction buffer
+ * is the sole content-bearing exception, and it evicts on delivery.
+ *
+ * Corrupt or incompatible state is discarded and rebuilt rather than blocking:
+ * everything already scheduled lives in the OS and is unaffected, which is what
+ * makes discarding safe rather than destructive.
+ */
+import type { StateStore } from './store';
+import { type CollectionName, type Timestamped } from './caps';
+import type { AnchoringMode, RoutingPayload } from '../contract/notification';
+import type { StateHealth } from '../contract/diagnostics';
+import { type DiagnosticCode } from '../contract/errors';
+/**
+ * Bumped whenever the shape below changes. A mismatch discards and rebuilds —
+ * never a migration, because none of this data is worth migrating and all of it
+ * is reconstructible.
+ */
+export declare const STATE_SCHEMA_VERSION = 1;
+export interface DedupEntry extends Timestamped {
+    readonly dedupId: string;
+    readonly ownerTag?: string;
+}
+export interface BufferedInteraction extends Timestamped {
+    readonly id: string;
+    readonly kind: 'tap' | 'action' | 'dismiss';
+    readonly notificationId: string;
+    readonly actionId?: string;
+    /**
+     * Only ever present in a record written before 0.5: typed replies are no
+     * longer persisted (interaction-buffer.ts).
+     */
+    readonly inputText?: string;
+    /** The one content-bearing thing persisted. Evicted the moment it is delivered. */
+    readonly routing?: RoutingPayload;
+    readonly ownerTag?: string;
+}
+export interface MigrationEntry extends Timestamped {
+    readonly toneId: string;
+    readonly appliedVersion: number;
+    readonly channelId: string;
+    readonly retired: boolean;
+    /**
+     * Fingerprint of the labels last pushed to the platform.
+     *
+     * Optional because records written before labels were carried at all have
+     * none — and their absence is exactly right: an unknown fingerprint refreshes
+     * once, which is the one-time correction every existing device needs, since
+     * every existing channel currently carries the tone id as its name.
+     *
+     * A fingerprint rather than the labels themselves. Persisted state holds no
+     * consumer text, and a hash answers the only question asked of it.
+     */
+    readonly labelFingerprint?: string;
+}
+export interface SeriesEntry extends Timestamped {
+    readonly seriesId: string;
+    readonly anchoring: AnchoringMode;
+    readonly expandedThrough: number;
+    readonly emittedCount: number;
+    readonly exhausted: boolean;
+    /**
+     * Calendar key of the latest occurrence counted into `emittedCount`. Absent in
+     * entries written before 0.4.0; recovered from the device on next expansion.
+     */
+    readonly lastEmittedKey?: string;
+}
+export interface PermissionHistoryEntry extends Timestamped {
+    readonly key: string;
+    readonly requested: boolean;
+    /** Requests the user refused, so a permanent denial can be told apart (0.6.0). */
+    readonly denials?: number;
+}
+export interface StateRecord {
+    readonly schemaVersion: number;
+    readonly dedupLedger: readonly DedupEntry[];
+    readonly interactionBuffer: readonly BufferedInteraction[];
+    readonly migrationLedger: readonly MigrationEntry[];
+    readonly seriesLedger: readonly SeriesEntry[];
+    readonly permissionHistory: readonly PermissionHistoryEntry[];
+    readonly lastReconcileSummary?: Readonly<Record<string, unknown>>;
+    readonly lastMaintenanceSummary?: Readonly<Record<string, unknown>>;
+}
+export declare function emptyRecord(): StateRecord;
+export interface StateEvent {
+    readonly code: DiagnosticCode;
+    readonly context?: Readonly<Record<string, unknown>>;
+}
+export interface StateManagerOptions {
+    readonly store: StateStore;
+    readonly now: () => number;
+    readonly emit?: (event: StateEvent) => void;
+}
+/**
+ * Owns the record's lifecycle. Reads are synchronous and cheap; writes are
+ * best-effort and never propagate a failure to the caller's operation.
+ */
+export declare class StateManager {
+    private record;
+    private rebuilt;
+    private readonly store;
+    private readonly now;
+    private readonly emit;
+    constructor(options: StateManagerOptions);
+    private load;
+    /** Reads the pre-0.6.0 single record, writes it out per collection, and drops it. */
+    private migrateLegacy;
+    private discardAndRebuild;
+    private deleteAll;
+    /** Never throws. A storage failure degrades the affected guarantee, nothing more. */
+    private write;
+    /** Writes one collection, and only that one. */
+    private persist;
+    /** The schema version and summaries. Present whenever any collection is stored. */
+    private persistMeta;
+    read(): StateRecord;
+    /** Applies a change, evicts the touched collection, and persists. */
+    update<K extends CollectionName>(collection: K, mutate: (current: StateRecord[K]) => StateRecord[K]): void;
+    setSummary(key: 'lastReconcileSummary' | 'lastMaintenanceSummary', value: Readonly<Record<string, unknown>>): void;
+    /** Clears everything. Public through `resetState()`. */
+    reset(): void;
+    /**
+     * Clears one owner tag's entries, leaving every other tag untouched.
+     *
+     * Collections without an owner tag are left alone: a migration ledger and a
+     * series ledger describe the device, not an account.
+     */
+    clearOwner(ownerTag: string): void;
+    health(): StateHealth;
+}
+//# sourceMappingURL=record.d.ts.map

package/lib/typescript/commonjs/state/record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"record.d.ts","sourceRoot":"","sources":["../../../../src/state/record.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAC1C,OAAO,EAA0B,KAAK,cAAc,EAAE,KAAK,WAAW,EAAE,MAAM,QAAQ,CAAC;AACvF,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC9E,OAAO,KAAK,EAAoB,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC7E,OAAO,EAAoB,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAoB3E;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAEtC,MAAM,WAAW,UAAW,SAAQ,WAAW;IAC9C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,mBAAoB,SAAQ,WAAW;IACvD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,KAAK,GAAG,QAAQ,GAAG,SAAS,CAAC;IAC5C,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,mFAAmF;IACnF,QAAQ,CAAC,OAAO,CAAC,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,cAAe,SAAQ,WAAW;IAClD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CACnC;AAED,MAAM,WAAW,WAAY,SAAQ,WAAW;IAC/C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC;IAClC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B;;;OAGG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CACjC;AAED,MAAM,WAAW,sBAAuB,SAAQ,WAAW;IAC1D,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,kFAAkF;IAClF,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,WAAW;IAC3B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,WAAW,EAAE,SAAS,UAAU,EAAE,CAAC;IAC5C,QAAQ,CAAC,iBAAiB,EAAE,SAAS,mBAAmB,EAAE,CAAC;IAC3D,QAAQ,CAAC,eAAe,EAAE,SAAS,cAAc,EAAE,CAAC;IACpD,QAAQ,CAAC,YAAY,EAAE,SAAS,WAAW,EAAE,CAAC;IAC9C,QAAQ,CAAC,iBAAiB,EAAE,SAAS,sBAAsB,EAAE,CAAC;IAC9D,QAAQ,CAAC,oBAAoB,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAClE,QAAQ,CAAC,sBAAsB,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACpE;AAED,wBAAgB,WAAW,IAAI,WAAW,CASzC;AAED,MAAM,WAAW,UAAU;IAC1B,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACrD;AAED,MAAM,WAAW,mBAAmB;IACnC,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,QAAQ,CAAC,GAAG,EAAE,MAAM,MAAM,CAAC;IAC3B,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;CAC5C;AAED;;;GAGG;AACH,qBAAa,YAAY;IACxB,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAa;IACnC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAe;IACnC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA8B;gBAEvC,OAAO,EAAE,mBAAmB;IAOxC,OAAO,CAAC,IAAI;IAgCZ,qFAAqF;IACrF,OAAO,CAAC,aAAa;IAgCrB,OAAO,CAAC,iBAAiB;IAezB,OAAO,CAAC,SAAS;IAQjB,qFAAqF;IACrF,OAAO,CAAC,KAAK;IAWb,gDAAgD;IAChD,OAAO,CAAC,OAAO;IAIf,mFAAmF;IACnF,OAAO,CAAC,WAAW;IAQnB,IAAI,IAAI,WAAW;IAInB,qEAAqE;IACrE,MAAM,CAAC,CAAC,SAAS,cAAc,EAC9B,UAAU,EAAE,CAAC,EACb,MAAM,EAAE,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,WAAW,CAAC,CAAC,CAAC,GACjD,IAAI;IA4BP,UAAU,CACT,GAAG,EAAE,sBAAsB,GAAG,wBAAwB,EACtD,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACtC,IAAI;IAKP,wDAAwD;IACxD,KAAK,IAAI,IAAI;IAOb;;;;;OAKG;IACH,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAclC,MAAM,IAAI,WAAW;CAoBrB"}

package/lib/typescript/commonjs/state/reset.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Public state reset and per-owner clearing.
+ *
+ * These are the only two ways a consumer may touch the persisted record. The
+ * record itself is unreachable — a consumer can discard state, but can never
+ * read or write it.
+ */
+import type { StateManager } from './record';
+export interface ResetOutcome {
+    readonly clearedCollections: readonly string[];
+}
+/** Discards the entire record. Nothing already scheduled with the OS is affected. */
+export declare function resetState(state: StateManager): ResetOutcome;
+/**
+ * Clears one owner tag's entries on sign-out.
+ *
+ * Deliberately narrower than a full reset: the migration and series ledgers
+ * describe the device rather than an account, so signing one account out must
+ * not discard channel migration history that every account depends on.
+ */
+export declare function clearOwner(state: StateManager, ownerTag: string): ResetOutcome;
+//# sourceMappingURL=reset.d.ts.map

package/lib/typescript/commonjs/state/reset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reset.d.ts","sourceRoot":"","sources":["../../../../src/state/reset.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C,MAAM,WAAW,YAAY;IAC5B,QAAQ,CAAC,kBAAkB,EAAE,SAAS,MAAM,EAAE,CAAC;CAC/C;AAED,qFAAqF;AACrF,wBAAgB,UAAU,CAAC,KAAK,EAAE,YAAY,GAAG,YAAY,CAW5D;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,GAAG,YAAY,CAK9E"}

package/lib/typescript/commonjs/state/series-ledger.d.ts

@@ -0,0 +1,47 @@
+/**
+ * The recurrence series ledger.
+ *
+ * What makes automatic maintenance possible without a desired set from the
+ * consumer: the package remembers which series it owns, how far each has been
+ * expanded, and how many occurrences a count-limited series has already
+ * emitted. None of that is derivable from the platform's pending set, which
+ * knows only about individual notifications.
+ *
+ * It also defines what maintenance is allowed to touch. An occurrence belongs
+ * to a series in this ledger, so cancelling it is within scope; anything else
+ * is a directly-scheduled notification the package does not own.
+ */
+import type { StateManager } from './record';
+import type { RecurrenceRule } from '../contract/recurrence';
+import type { AnchoringMode } from '../contract/notification';
+export interface SeriesRecord {
+    readonly seriesId: string;
+    readonly anchoring: AnchoringMode;
+    readonly expandedThrough: number;
+    readonly emittedCount: number;
+    readonly exhausted: boolean;
+    readonly lastEmittedKey?: string;
+    readonly at: number;
+}
+export declare function readSeries(state: StateManager, seriesId: string): SeriesRecord | undefined;
+export declare function listSeries(state: StateManager): readonly SeriesRecord[];
+/** Records or updates a series. Replaces in place so a re-registration cannot duplicate. */
+export declare function upsertSeries(state: StateManager, rule: RecurrenceRule, update: {
+    readonly expandedThrough: number;
+    readonly emittedCount: number;
+    readonly exhausted: boolean;
+    readonly lastEmittedKey?: string;
+}, now: number): void;
+export declare function removeSeries(state: StateManager, seriesId: string): void;
+/**
+ * Identifiers the package owns.
+ *
+ * An occurrence identifier is `<seriesId>#<instant>`, so ownership is decided
+ * by prefix rather than by an enumeration the ledger would have to keep in sync
+ * with the device. That keeps the check correct even for occurrences scheduled
+ * before the app last restarted.
+ */
+export declare function ownsIdentifier(state: StateManager, id: string): boolean;
+/** Every occurrence identifier currently attributable to a tracked series. */
+export declare function ownedIdentifiers(state: StateManager, pendingIds: readonly string[]): ReadonlySet<string>;
+//# sourceMappingURL=series-ledger.d.ts.map

package/lib/typescript/commonjs/state/series-ledger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"series-ledger.d.ts","sourceRoot":"","sources":["../../../../src/state/series-ledger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAe,MAAM,UAAU,CAAC;AAC1D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAE9D,MAAM,WAAW,YAAY;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC;IAClC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACpB;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAE1F;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,YAAY,GAAG,SAAS,YAAY,EAAE,CAEvE;AAED,4FAA4F;AAC5F,wBAAgB,YAAY,CAC3B,KAAK,EAAE,YAAY,EACnB,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE;IACP,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CACjC,EACD,GAAG,EAAE,MAAM,GACT,IAAI,CAeN;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAExE;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,YAAY,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAMvE;AAED,8EAA8E;AAC9E,wBAAgB,gBAAgB,CAC/B,KAAK,EAAE,YAAY,EACnB,UAAU,EAAE,SAAS,MAAM,EAAE,GAC3B,WAAW,CAAC,MAAM,CAAC,CAErB"}

package/lib/typescript/commonjs/state/store.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The storage port behind the persisted state record.
+ *
+ * Kept as a port so the pure state logic is testable with no native module,
+ * and so MMKV stays confined to one file. This is internal — a consumer can
+ * reset or clear state, but can never read or write the record directly.
+ */
+export interface StateStore {
+    getString(key: string): string | undefined;
+    setString(key: string, value: string): void;
+    delete(key: string): void;
+    clearAll(): void;
+    /** Approximate on-disk size, for the health report. */
+    approximateBytes(): number;
+    /** False when writes do not survive a restart (the memory fallback). */
+    readonly durable?: boolean;
+}
+/** In-memory store, used by tests and as the fallback when MMKV is unavailable. */
+export declare function createMemoryStore(): StateStore;
+//# sourceMappingURL=store.d.ts.map

package/lib/typescript/commonjs/state/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../../src/state/store.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,WAAW,UAAU;IAC1B,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IAC3C,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5C,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,QAAQ,IAAI,IAAI,CAAC;IACjB,uDAAuD;IACvD,gBAAgB,IAAI,MAAM,CAAC;IAC3B,wEAAwE;IACxE,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,mFAAmF;AACnF,wBAAgB,iBAAiB,IAAI,UAAU,CAsB9C"}