@aigne/afs-did-space 1.12.0-beta.5

package/dist/local-changelog.cjs

@@ -0,0 +1,241 @@
+const require_changelog_schema = require('./changelog-schema.cjs');
+
+//#region src/local-changelog.ts
+/**
+* LocalChangelog — Phase 3 Task 3.4 (G6)
+*
+* Read-side + GC companion to the `changelog` writes produced by
+* MetadataDB / D1TreeIndex / SQLiteTreeIndex. Used exclusively by the
+* local SyncEngine (desktop + mobile); has NO counterpart inside the
+* CloudflareDIDSpace Worker — the server IS the cloud changelog, it has
+* no notion of "unpushed local rows".
+*
+* Responsibilities:
+*
+*  1. `getUnpushed(sinceSeq, limit?)`
+*     Return changelog rows written by THIS device (`device_id == self`)
+*     whose `seq > sinceSeq`, ordered by seq ascending. SyncEngine pages
+*     through these on the push leg of each sync round.
+*
+*  2. `markPushed(upToSeq)`
+*     Advance `sync_state['{scope}:local_seq']` to record that all self-
+*     written rows up to `upToSeq` have been accepted by the server. Does
+*     NOT delete anything — row retention is owned by `gc()`. The watermark
+*     is strictly monotonic (setting a lower value is a no-op).
+*
+*  3. `gc()`
+*     Single atomic DELETE that removes:
+*       (a) rows from THIS device with seq ≤ local_seq (pushed, no longer
+*           needed for resume) AND
+*       (b) rows from OTHER devices with seq ≤ cloud_seq (pulled + applied,
+*           no longer needed for replay).
+*     Called by SyncEngine AFTER a successful sync round. The gc contract
+*     is called-by-engine — gc() itself makes no assumption about timing.
+*
+*  4. `getLocalSeq` / `getCloudSeq` / `setCloudSeq`
+*     Helpers for SyncEngine and tests. Task 3.5 introduces a richer
+*     `SyncStateStore` that owns these KV lookups with Keychain/Keystore
+*     backing; for Task 3.4 we keep the reads/writes inside LocalChangelog
+*     so the module is self-contained and pre-3.5 integration tests work.
+*
+* The `sync_state` KV table is created by `ensureTable()` — idempotent —
+* and must be present before any of the methods above are called. The DDL
+* lives in `changelog-schema.ts` and is byte-identical across TypeScript,
+* Swift, and Kotlin (Task 3.5 will add a parity check once the schema
+* extends with Keychain-backed keys).
+*
+* Scope isolation: every SQL statement inside LocalChangelog includes a
+* `scope = ?` bind. Cross-scope leaks would regress Task 2.1's scope-
+* scoped changelog design, so both gc() and getUnpushed() carry the scope
+* through explicitly.
+*/
+/** Default `limit` applied by `getUnpushed` when none is specified. */
+const LOCAL_CHANGELOG_DEFAULT_LIMIT = 1e3;
+/** Maximum `limit` accepted by `getUnpushed`; larger values are clamped. */
+const LOCAL_CHANGELOG_MAX_LIMIT = 1e4;
+function toChangelogEntry(row) {
+	const r = row;
+	return {
+		seq: Number(r.seq),
+		scope: r.scope,
+		path: r.path,
+		op: r.op,
+		cid: r.cid ?? null,
+		old_cid: r.old_cid ?? null,
+		size: r.size === null || r.size === void 0 ? null : Number(r.size),
+		mtime: Number(r.mtime),
+		device_id: r.device_id
+	};
+}
+var LocalChangelog = class {
+	client;
+	scope;
+	deviceId;
+	constructor(opts) {
+		if (typeof opts.scope !== "string" || opts.scope.length === 0) throw new Error("LocalChangelog: scope must be a non-empty string");
+		if (typeof opts.deviceId !== "string" || opts.deviceId.length === 0) throw new Error("LocalChangelog: deviceId must be a non-empty string");
+		this.client = opts.client;
+		this.scope = opts.scope;
+		this.deviceId = opts.deviceId;
+	}
+	/**
+	* Idempotently create the `sync_state` table (and any future indices).
+	*
+	* MetadataDB.open() calls this on desktop; mobile runtimes run the DDL
+	* inline from their own migrate(). Safe to call from tests that
+	* construct LocalChangelog directly on a raw libsql client.
+	*/
+	static async ensureTable(client) {
+		await client.execute(require_changelog_schema.SYNC_STATE_TABLE_SQL);
+		for (const sql of require_changelog_schema.SYNC_STATE_INDEX_SQL) await client.execute(sql);
+	}
+	/**
+	* Read the `local_seq` watermark — highest changelog.seq that the current
+	* device has acknowledged as pushed. Returns 0 when the key is missing
+	* (nothing pushed yet).
+	*/
+	async getLocalSeq() {
+		return this.readSeqKey(`${this.scope}:local_seq`);
+	}
+	/**
+	* Read the `cloud_seq` watermark — highest changelog.seq from OTHER
+	* devices that the current device has applied locally. Task 3.4 does
+	* not write this key itself; Task 3.5's SyncEngine will advance it as
+	* part of the pull leg. Returns 0 as the "nothing pulled yet" sentinel.
+	*/
+	async getCloudSeq() {
+		return this.readSeqKey(`${this.scope}:cloud_seq`);
+	}
+	/**
+	* Test / SyncEngine helper to advance the cloud_seq watermark.
+	*
+	* Monotonic: a caller passing a lower value than the stored watermark
+	* is a no-op. This matches Task 3.5's eventual API contract and keeps
+	* LocalChangelog's GC branch for "other devices" safe under retries.
+	*/
+	async setCloudSeq(seq) {
+		await this.writeSeqKeyMonotonic(`${this.scope}:cloud_seq`, seq);
+	}
+	/**
+	* Low-level SELECT for a `sync_state` integer key. Returns 0 when the
+	* key is missing. Throws on non-numeric values (corrupt state).
+	*/
+	async readSeqKey(key) {
+		const result = await this.client.execute({
+			sql: "SELECT value FROM ds_sync_state WHERE key = ?",
+			args: [key]
+		});
+		if (result.rows.length === 0) return 0;
+		const raw = result.rows[0][0];
+		if (raw === null || raw === void 0) return 0;
+		const value = typeof raw === "string" ? raw : String(raw);
+		const parsed = Number(value);
+		if (!Number.isFinite(parsed) || !Number.isInteger(parsed)) throw new Error(`LocalChangelog: corrupt sync_state value for key=${key}: ${value}`);
+		return parsed;
+	}
+	/**
+	* Monotonic INSERT-OR-REPLACE for a `sync_state` integer key. The CASE
+	* expression keeps the prior value when the incoming one is lower.
+	*
+	* Negative inputs are clamped to 0 so misbehaving callers cannot rewind
+	* the watermark below the "nothing synced yet" sentinel.
+	*/
+	async writeSeqKeyMonotonic(key, seq) {
+		const safe = Math.max(0, Math.floor(Number.isFinite(seq) ? seq : 0));
+		await this.client.execute({
+			sql: `INSERT INTO ds_sync_state (key, value) VALUES (?, ?)
+            ON CONFLICT(key) DO UPDATE SET
+              value = CASE
+                WHEN CAST(excluded.value AS INTEGER) > CAST(ds_sync_state.value AS INTEGER)
+                THEN excluded.value
+                ELSE ds_sync_state.value
+              END`,
+			args: [key, String(safe)]
+		});
+	}
+	/**
+	* Return self-written changelog rows with seq > sinceSeq, ordered by seq
+	* ascending. Rows from other devices are excluded at the SQL layer
+	* (device_id filter) so this function is cheap even on multi-device
+	* spaces with heavy pull traffic.
+	*
+	* Clamping rules (matches G5.a Worker endpoint for consistency):
+	*   - sinceSeq < 0 → clamped to 0 (not rejected; caller is internal)
+	*   - limit undefined → LOCAL_CHANGELOG_DEFAULT_LIMIT (1000)
+	*   - limit === 0 → returns [] without hitting SQLite
+	*   - limit > LOCAL_CHANGELOG_MAX_LIMIT → clamped to 10000
+	*/
+	async getUnpushed(sinceSeq, limit) {
+		const safeSince = Math.max(0, Math.floor(Number.isFinite(sinceSeq) ? sinceSeq : 0));
+		const requested = limit ?? LOCAL_CHANGELOG_DEFAULT_LIMIT;
+		if (requested === 0) return [];
+		const safeLimit = Math.min(LOCAL_CHANGELOG_MAX_LIMIT, Math.max(0, Math.floor(Number.isFinite(requested) ? requested : 0)));
+		if (safeLimit === 0) return [];
+		return (await this.client.execute({
+			sql: `SELECT seq, scope, path, op, cid, old_cid, size, mtime, device_id
+            FROM ds_changelog
+            WHERE scope = ? AND device_id = ? AND seq > ?
+            ORDER BY seq ASC
+            LIMIT ?`,
+			args: [
+				this.scope,
+				this.deviceId,
+				safeSince,
+				safeLimit
+			]
+		})).rows.map(toChangelogEntry);
+	}
+	/**
+	* Advance the `local_seq` watermark to `upToSeq`. Does NOT delete rows;
+	* `gc()` is the only path that removes data.
+	*
+	* Monotonic: calls with `upToSeq` less than or equal to the stored
+	* watermark become no-ops. This keeps the invariant that SyncEngine can
+	* safely retry pushes without rewinding progress.
+	*/
+	async markPushed(upToSeq) {
+		await this.writeSeqKeyMonotonic(`${this.scope}:local_seq`, upToSeq);
+	}
+	/**
+	* Atomically delete self-pushed rows (seq ≤ local_seq) AND other-device
+	* rows that have been applied locally (seq ≤ cloud_seq).
+	*
+	* Rows that do NOT match either branch — e.g. other-device rows above
+	* cloud_seq, or self rows above local_seq — remain untouched. This is
+	* the non-negotiable safety rule: GC must never remove a row whose
+	* application is still pending.
+	*
+	* Implementation note: we read local_seq + cloud_seq BEFORE issuing the
+	* DELETE and bake them into the WHERE clause. This keeps the DELETE a
+	* single statement (the spec mandates a single-shot DELETE, not a
+	* row-by-row loop) and makes the semantics easy to reason about under
+	* concurrent gc() invocations — each call operates on a point-in-time
+	* snapshot of the watermarks.
+	*/
+	async gc() {
+		const localSeq = await this.getLocalSeq();
+		const cloudSeq = await this.getCloudSeq();
+		const result = await this.client.execute({
+			sql: `DELETE FROM ds_changelog
+            WHERE scope = ?
+              AND (
+                (device_id = ?  AND seq <= ?)
+                OR
+                (device_id != ? AND seq <= ?)
+              )`,
+			args: [
+				this.scope,
+				this.deviceId,
+				localSeq,
+				this.deviceId,
+				cloudSeq
+			]
+		});
+		return { deleted: Number(result.rowsAffected ?? 0) };
+	}
+};
+
+//#endregion
+exports.LOCAL_CHANGELOG_DEFAULT_LIMIT = LOCAL_CHANGELOG_DEFAULT_LIMIT;
+exports.LOCAL_CHANGELOG_MAX_LIMIT = LOCAL_CHANGELOG_MAX_LIMIT;
+exports.LocalChangelog = LocalChangelog;

package/dist/local-changelog.d.cts

@@ -0,0 +1,119 @@
+import { ChangelogEntry } from "./tree-index.cjs";
+import * as _libsql_client0 from "@libsql/client";
+
+//#region src/local-changelog.d.ts
+/** Default `limit` applied by `getUnpushed` when none is specified. */
+declare const LOCAL_CHANGELOG_DEFAULT_LIMIT = 1000;
+/** Maximum `limit` accepted by `getUnpushed`; larger values are clamped. */
+declare const LOCAL_CHANGELOG_MAX_LIMIT = 10000;
+interface LocalChangelogOptions {
+  /**
+   * Already-opened libsql client sharing the same DB file as the TreeIndex.
+   * LocalChangelog does NOT own the client lifecycle — callers (typically
+   * `DIDSpaceProvider` construction) remain responsible for close().
+   */
+  client: _libsql_client0.Client;
+  /** Scope string written into `changelog` and used to partition `sync_state` keys. */
+  scope: string;
+  /**
+   * Device identifier of the current process. Used BOTH as the `self` filter
+   * for `getUnpushed` AND as the branch discriminator in `gc()`.
+   *
+   * Task 3.4 takes this via constructor injection. Task 3.5 will wire the
+   * argument to a Keychain/Keystore-backed SyncStateStore without changing
+   * LocalChangelog's public surface.
+   */
+  deviceId: string;
+}
+declare class LocalChangelog {
+  private readonly client;
+  private readonly scope;
+  private readonly deviceId;
+  constructor(opts: LocalChangelogOptions);
+  /**
+   * Idempotently create the `sync_state` table (and any future indices).
+   *
+   * MetadataDB.open() calls this on desktop; mobile runtimes run the DDL
+   * inline from their own migrate(). Safe to call from tests that
+   * construct LocalChangelog directly on a raw libsql client.
+   */
+  static ensureTable(client: _libsql_client0.Client): Promise<void>;
+  /**
+   * Read the `local_seq` watermark — highest changelog.seq that the current
+   * device has acknowledged as pushed. Returns 0 when the key is missing
+   * (nothing pushed yet).
+   */
+  getLocalSeq(): Promise<number>;
+  /**
+   * Read the `cloud_seq` watermark — highest changelog.seq from OTHER
+   * devices that the current device has applied locally. Task 3.4 does
+   * not write this key itself; Task 3.5's SyncEngine will advance it as
+   * part of the pull leg. Returns 0 as the "nothing pulled yet" sentinel.
+   */
+  getCloudSeq(): Promise<number>;
+  /**
+   * Test / SyncEngine helper to advance the cloud_seq watermark.
+   *
+   * Monotonic: a caller passing a lower value than the stored watermark
+   * is a no-op. This matches Task 3.5's eventual API contract and keeps
+   * LocalChangelog's GC branch for "other devices" safe under retries.
+   */
+  setCloudSeq(seq: number): Promise<void>;
+  /**
+   * Low-level SELECT for a `sync_state` integer key. Returns 0 when the
+   * key is missing. Throws on non-numeric values (corrupt state).
+   */
+  private readSeqKey;
+  /**
+   * Monotonic INSERT-OR-REPLACE for a `sync_state` integer key. The CASE
+   * expression keeps the prior value when the incoming one is lower.
+   *
+   * Negative inputs are clamped to 0 so misbehaving callers cannot rewind
+   * the watermark below the "nothing synced yet" sentinel.
+   */
+  private writeSeqKeyMonotonic;
+  /**
+   * Return self-written changelog rows with seq > sinceSeq, ordered by seq
+   * ascending. Rows from other devices are excluded at the SQL layer
+   * (device_id filter) so this function is cheap even on multi-device
+   * spaces with heavy pull traffic.
+   *
+   * Clamping rules (matches G5.a Worker endpoint for consistency):
+   *   - sinceSeq < 0 → clamped to 0 (not rejected; caller is internal)
+   *   - limit undefined → LOCAL_CHANGELOG_DEFAULT_LIMIT (1000)
+   *   - limit === 0 → returns [] without hitting SQLite
+   *   - limit > LOCAL_CHANGELOG_MAX_LIMIT → clamped to 10000
+   */
+  getUnpushed(sinceSeq: number, limit?: number): Promise<ChangelogEntry[]>;
+  /**
+   * Advance the `local_seq` watermark to `upToSeq`. Does NOT delete rows;
+   * `gc()` is the only path that removes data.
+   *
+   * Monotonic: calls with `upToSeq` less than or equal to the stored
+   * watermark become no-ops. This keeps the invariant that SyncEngine can
+   * safely retry pushes without rewinding progress.
+   */
+  markPushed(upToSeq: number): Promise<void>;
+  /**
+   * Atomically delete self-pushed rows (seq ≤ local_seq) AND other-device
+   * rows that have been applied locally (seq ≤ cloud_seq).
+   *
+   * Rows that do NOT match either branch — e.g. other-device rows above
+   * cloud_seq, or self rows above local_seq — remain untouched. This is
+   * the non-negotiable safety rule: GC must never remove a row whose
+   * application is still pending.
+   *
+   * Implementation note: we read local_seq + cloud_seq BEFORE issuing the
+   * DELETE and bake them into the WHERE clause. This keeps the DELETE a
+   * single statement (the spec mandates a single-shot DELETE, not a
+   * row-by-row loop) and makes the semantics easy to reason about under
+   * concurrent gc() invocations — each call operates on a point-in-time
+   * snapshot of the watermarks.
+   */
+  gc(): Promise<{
+    deleted: number;
+  }>;
+}
+//#endregion
+export { LOCAL_CHANGELOG_DEFAULT_LIMIT, LOCAL_CHANGELOG_MAX_LIMIT, LocalChangelog, LocalChangelogOptions };
+//# sourceMappingURL=local-changelog.d.cts.map

package/dist/local-changelog.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-changelog.d.cts","names":[],"sources":["../src/local-changelog.ts"],"mappings":";;;;;cAqDa,6BAAA;;cAGA,yBAAA;AAAA,UAEI,qBAAA;EA6GG;;;;;EAvGlB,MAAA,EANoC,eAAA,CAMH,MAAA;EAkKG;EA/JpC,KAAA;EA+J6D;;;;;;;;EArJ7D,QAAA;AAAA;AAAA,cA+BW,cAAA;EAAA,iBACM,MAAA;EAAA,iBACA,KAAA;EAAA,iBACA,QAAA;cAEL,IAAA,EAAM,qBAAA;;;;;;;;SAmBL,WAAA,CAAY,MAAA,EAnBc,eAAA,CAmBmB,MAAA,GAAS,OAAA;;;;;;EAc7D,WAAA,CAAA,GAAe,OAAA;;;;;;;EAUf,WAAA,CAAA,GAAe,OAAA;;;;;;;;EAWf,WAAA,CAAY,GAAA,WAAc,OAAA;;;;;UAQlB,UAAA;;;;;;;;UAuBA,oBAAA;;;;;;;;;;;;;EA4BR,WAAA,CAAY,QAAA,UAAkB,KAAA,YAAiB,OAAA,CAAQ,cAAA;;;;;;;;;EA6BvD,UAAA,CAAW,OAAA,WAAkB,OAAA;;;;;;;;;;;;;;;;;EAoB7B,EAAA,CAAA,GAAM,OAAA;IAAU,OAAA;EAAA;AAAA"}

package/dist/local-changelog.d.mts

@@ -0,0 +1,119 @@
+import { ChangelogEntry } from "./tree-index.mjs";
+import * as _libsql_client0 from "@libsql/client";
+
+//#region src/local-changelog.d.ts
+/** Default `limit` applied by `getUnpushed` when none is specified. */
+declare const LOCAL_CHANGELOG_DEFAULT_LIMIT = 1000;
+/** Maximum `limit` accepted by `getUnpushed`; larger values are clamped. */
+declare const LOCAL_CHANGELOG_MAX_LIMIT = 10000;
+interface LocalChangelogOptions {
+  /**
+   * Already-opened libsql client sharing the same DB file as the TreeIndex.
+   * LocalChangelog does NOT own the client lifecycle — callers (typically
+   * `DIDSpaceProvider` construction) remain responsible for close().
+   */
+  client: _libsql_client0.Client;
+  /** Scope string written into `changelog` and used to partition `sync_state` keys. */
+  scope: string;
+  /**
+   * Device identifier of the current process. Used BOTH as the `self` filter
+   * for `getUnpushed` AND as the branch discriminator in `gc()`.
+   *
+   * Task 3.4 takes this via constructor injection. Task 3.5 will wire the
+   * argument to a Keychain/Keystore-backed SyncStateStore without changing
+   * LocalChangelog's public surface.
+   */
+  deviceId: string;
+}
+declare class LocalChangelog {
+  private readonly client;
+  private readonly scope;
+  private readonly deviceId;
+  constructor(opts: LocalChangelogOptions);
+  /**
+   * Idempotently create the `sync_state` table (and any future indices).
+   *
+   * MetadataDB.open() calls this on desktop; mobile runtimes run the DDL
+   * inline from their own migrate(). Safe to call from tests that
+   * construct LocalChangelog directly on a raw libsql client.
+   */
+  static ensureTable(client: _libsql_client0.Client): Promise<void>;
+  /**
+   * Read the `local_seq` watermark — highest changelog.seq that the current
+   * device has acknowledged as pushed. Returns 0 when the key is missing
+   * (nothing pushed yet).
+   */
+  getLocalSeq(): Promise<number>;
+  /**
+   * Read the `cloud_seq` watermark — highest changelog.seq from OTHER
+   * devices that the current device has applied locally. Task 3.4 does
+   * not write this key itself; Task 3.5's SyncEngine will advance it as
+   * part of the pull leg. Returns 0 as the "nothing pulled yet" sentinel.
+   */
+  getCloudSeq(): Promise<number>;
+  /**
+   * Test / SyncEngine helper to advance the cloud_seq watermark.
+   *
+   * Monotonic: a caller passing a lower value than the stored watermark
+   * is a no-op. This matches Task 3.5's eventual API contract and keeps
+   * LocalChangelog's GC branch for "other devices" safe under retries.
+   */
+  setCloudSeq(seq: number): Promise<void>;
+  /**
+   * Low-level SELECT for a `sync_state` integer key. Returns 0 when the
+   * key is missing. Throws on non-numeric values (corrupt state).
+   */
+  private readSeqKey;
+  /**
+   * Monotonic INSERT-OR-REPLACE for a `sync_state` integer key. The CASE
+   * expression keeps the prior value when the incoming one is lower.
+   *
+   * Negative inputs are clamped to 0 so misbehaving callers cannot rewind
+   * the watermark below the "nothing synced yet" sentinel.
+   */
+  private writeSeqKeyMonotonic;
+  /**
+   * Return self-written changelog rows with seq > sinceSeq, ordered by seq
+   * ascending. Rows from other devices are excluded at the SQL layer
+   * (device_id filter) so this function is cheap even on multi-device
+   * spaces with heavy pull traffic.
+   *
+   * Clamping rules (matches G5.a Worker endpoint for consistency):
+   *   - sinceSeq < 0 → clamped to 0 (not rejected; caller is internal)
+   *   - limit undefined → LOCAL_CHANGELOG_DEFAULT_LIMIT (1000)
+   *   - limit === 0 → returns [] without hitting SQLite
+   *   - limit > LOCAL_CHANGELOG_MAX_LIMIT → clamped to 10000
+   */
+  getUnpushed(sinceSeq: number, limit?: number): Promise<ChangelogEntry[]>;
+  /**
+   * Advance the `local_seq` watermark to `upToSeq`. Does NOT delete rows;
+   * `gc()` is the only path that removes data.
+   *
+   * Monotonic: calls with `upToSeq` less than or equal to the stored
+   * watermark become no-ops. This keeps the invariant that SyncEngine can
+   * safely retry pushes without rewinding progress.
+   */
+  markPushed(upToSeq: number): Promise<void>;
+  /**
+   * Atomically delete self-pushed rows (seq ≤ local_seq) AND other-device
+   * rows that have been applied locally (seq ≤ cloud_seq).
+   *
+   * Rows that do NOT match either branch — e.g. other-device rows above
+   * cloud_seq, or self rows above local_seq — remain untouched. This is
+   * the non-negotiable safety rule: GC must never remove a row whose
+   * application is still pending.
+   *
+   * Implementation note: we read local_seq + cloud_seq BEFORE issuing the
+   * DELETE and bake them into the WHERE clause. This keeps the DELETE a
+   * single statement (the spec mandates a single-shot DELETE, not a
+   * row-by-row loop) and makes the semantics easy to reason about under
+   * concurrent gc() invocations — each call operates on a point-in-time
+   * snapshot of the watermarks.
+   */
+  gc(): Promise<{
+    deleted: number;
+  }>;
+}
+//#endregion
+export { LOCAL_CHANGELOG_DEFAULT_LIMIT, LOCAL_CHANGELOG_MAX_LIMIT, LocalChangelog, LocalChangelogOptions };
+//# sourceMappingURL=local-changelog.d.mts.map

package/dist/local-changelog.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-changelog.d.mts","names":[],"sources":["../src/local-changelog.ts"],"mappings":";;;;;cAqDa,6BAAA;;cAGA,yBAAA;AAAA,UAEI,qBAAA;EA6GG;;;;;EAvGlB,MAAA,EANoC,eAAA,CAMH,MAAA;EAkKG;EA/JpC,KAAA;EA+J6D;;;;;;;;EArJ7D,QAAA;AAAA;AAAA,cA+BW,cAAA;EAAA,iBACM,MAAA;EAAA,iBACA,KAAA;EAAA,iBACA,QAAA;cAEL,IAAA,EAAM,qBAAA;;;;;;;;SAmBL,WAAA,CAAY,MAAA,EAnBc,eAAA,CAmBmB,MAAA,GAAS,OAAA;;;;;;EAc7D,WAAA,CAAA,GAAe,OAAA;;;;;;;EAUf,WAAA,CAAA,GAAe,OAAA;;;;;;;;EAWf,WAAA,CAAY,GAAA,WAAc,OAAA;;;;;UAQlB,UAAA;;;;;;;;UAuBA,oBAAA;;;;;;;;;;;;;EA4BR,WAAA,CAAY,QAAA,UAAkB,KAAA,YAAiB,OAAA,CAAQ,cAAA;;;;;;;;;EA6BvD,UAAA,CAAW,OAAA,WAAkB,OAAA;;;;;;;;;;;;;;;;;EAoB7B,EAAA,CAAA,GAAM,OAAA;IAAU,OAAA;EAAA;AAAA"}