@aigne/aos 0.2.0-beta

package/dist/session/settings-resolver.d.cts

@@ -0,0 +1,177 @@
+import { SettingsSchemaHandle } from "./settings-schema-store.cjs";
+import { AFSDeleteOptions, AFSDeleteResult, AFSEventCallback, AFSEventFilter, AFSListOptions, AFSListResult, AFSModule, AFSReadOptions, AFSReadResult, AFSRoot, AFSStatOptions, AFSStatResult, AFSUnsubscribe, AFSWriteEntryPayload, AFSWriteOptions, AFSWriteResult } from "@aigne/afs";
+
+//#region src/session/settings-resolver.d.ts
+/** Where a field's value is *declared* (the schema-level cascade tag). */
+type SettingsScope = "instance" | "user" | "shared";
+/** The physical layer a given caller reads/writes for a scope. */
+type SettingsLayer = "instance" | "user";
+interface SettingsResolverOptions {
+  /** The Small World base (owns `/instance/settings/<rel>` wrapper files). */
+  base: AFSRoot;
+  /** The caller's per-user provider (`/user` backing), or null for anonymous. */
+  userProvider: AFSModule | null;
+  /** The caller's role, from `getCallerForSession().role`. Unknown → non-admin. */
+  role: string | undefined;
+  /** Owning session id — used for event origin tagging in P4. */
+  sessionId: string;
+  /**
+   * Derived schema index handle (settings-layering Phase 1c). When wired, the
+   * resolver lazily materializes the blocklet's package-schema scope on first
+   * settings access (idempotent, store-side single-flight). Phase 2 makes it
+   * the existence/schema source; until then resolution is unchanged.
+   */
+  schema?: SettingsSchemaHandle | null;
+}
+declare class SettingsResolver implements AFSModule {
+  readonly name: string;
+  readonly accessMode: "readwrite";
+  private readonly base;
+  private readonly userProvider;
+  private readonly role;
+  private readonly schema;
+  /** Memoized lazy ingest — at most one ensure() flight per session. */
+  private schemaReady;
+  /**
+   * Outcome of the lazy ingest. `ready` = the package declares settings and
+   * the derived index is consumable (STORE MODE: existence/schema come from
+   * the package index). `empty` = package declares none; `failed` = store
+   * unavailable; `unwired` = no handle. All non-`ready` states resolve in
+   * LEGACY MODE (instance rows define existence + schema) — the pre-Phase-2
+   * behavior, so blocklets without package settings keep working.
+   */
+  private schemaState;
+  /**
+   * Active render snapshots, insertion-ordered by `beginRender`. Ops resolve
+   * against the MOST RECENTLY begun snapshot (walks are sequential per
+   * render; concurrent renders each get their own immutable entry).
+   */
+  private readonly snapshots;
+  constructor(opts: SettingsResolverOptions);
+  /**
+   * Lazily materialize the package-schema scope (Phase 1c plumbing). Memoized
+   * per resolver (per session); the store's own single-flight + completion
+   * marker make cross-session work idempotent. BEST-EFFORT in Phase 1: a
+   * failed ingest logs and falls back to legacy resolution (Phase 2 will
+   * consume the scope for existence/schema and define the hard contract).
+   */
+  private ensureSchemaIngested;
+  /** STORE MODE — existence/schema from the derived package index (§1.4). */
+  private get storeMode();
+  /**
+   * Begin a render-scoped snapshot. Called by the auto-surface walk entry
+   * point (via `SessionUserAFS.beginRender` proxy) with a fresh `renderId`
+   * before walking; the resolver builds the WHOLE settings snapshot once
+   * (1× derived-index listEntries + instance/user override list + sparse
+   * reads) and serves every list/read of that render from memory.
+   *
+   * Phase 0: contract only — no-op. Phase 2 implements the snapshot builder.
+   * Idempotency contract: repeated `beginRender` with the same renderId and
+   * `endRender` without a matching begin are both safe no-ops.
+   */
+  beginRender(renderId: string): Promise<void>;
+  /** Discard the render snapshot for `renderId`. See {@link beginRender}. */
+  endRender(renderId: string): void;
+  /** The snapshot ops resolve against: the most recently begun, still active. */
+  private get activeSnapshot();
+  /** Bulk-read + parse the derived package schemas (1 store query). */
+  private loadSchemaMap;
+  /**
+   * Walk one override layer's tree and read every `.json` row. Sparse by
+   * design (converged rows: 0-5); legacy instances pay row-count reads ONCE
+   * per render — all in-process, replacing the per-field WS round-trips.
+   */
+  private loadLayerRows;
+  private get isAuthed();
+  private get isOwnerOrAdmin();
+  /** The physical layer this caller reads AND writes for the given scope. */
+  resolveWriteLayer(scope: SettingsScope): SettingsLayer;
+  /** Presentation hint: should this caller's form render the field at all? */
+  visible(scope: SettingsScope): boolean;
+  /** Capability hint + (P1) write-enforcement basis: may this caller edit it? */
+  editable(scope: SettingsScope): boolean;
+  /** Normalize an incoming resolver-relative path; reject traversal outright. */
+  private normalizeSub;
+  /** Translate an underlying layer path back into the resolver-relative space. */
+  private underlyingToRelative;
+  private baseRead;
+  private baseStat;
+  private loadInstanceWrapper;
+  /** Read the caller's bare override value, or undefined when absent/anonymous. */
+  private readUserOverride;
+  /** Parsed package schema for a field, or null (store mode only). */
+  private getSchemaWrapper;
+  /** Parsed raw instance row, or null when absent (never throws not-found). */
+  private getInstanceRow;
+  /**
+   * Reduce a raw instance row to its OVERRIDE-ONLY contribution (§2.D):
+   * `value` (when present) + keys explicitly written under `overrides`.
+   * A LEGACY full wrapper's flat schema keys are deliberately dropped —
+   * the package schema is authoritative (legacy-no-shadow).
+   */
+  private stripToOverrideOnly;
+  /**
+   * Load one field through the cascade. Returns null when the field does not
+   * exist — store mode: not in the derived package index (orphan instance
+   * rows are IGNORED, §5.4.5); legacy mode: no instance row.
+   */
+  private loadField;
+  /** Opaque version of the layer this caller would write — §3.7. */
+  private writeTargetVersion;
+  read(path: string, options?: AFSReadOptions): Promise<AFSReadResult>;
+  /** Store-mode directory existence: any package field lives under `sub`. */
+  private dirExists;
+  /**
+   * The full schema map (store mode): from the active snapshot when present,
+   * else one bulk store query — replacing the legacy per-field N+1 scope peek.
+   */
+  private schemaMap;
+  list(path: string, options?: AFSListOptions): Promise<AFSListResult>;
+  stat(path: string, options?: AFSStatOptions): Promise<AFSStatResult>;
+  write(path: string, content: AFSWriteEntryPayload, options?: AFSWriteOptions): Promise<AFSWriteResult>;
+  /**
+   * The ON-DISK override-only shape of an instance row: `{ value?, overrides? }`.
+   * Distinct from {@link stripToOverrideOnly} (the flattened READ-side
+   * contribution) — this preserves the nested `overrides` object so a write
+   * RMW keeps prior explicit schema-text edits.
+   */
+  private overrideOnlyDiskShape;
+  /** Assemble write options, omitting empties so providers see a clean shape. */
+  private writeOptions;
+  /**
+   * Read-modify-write the FULL instance wrapper so siblings
+   * (label/description/options/…) survive — the G0 regression guard. ifMatch
+   * (if supplied) is compared by the base provider against the wrapper version;
+   * context (if supplied) flows through so the emitted event carries origin.
+   */
+  private writeInstanceWrapper;
+  delete(path: string, options?: AFSDeleteOptions): Promise<AFSDeleteResult>;
+  /**
+   * Bridge instance-layer + user-layer change events into the
+   * `/instance/settings/...` namespace so propBind can react to a cascade write
+   * regardless of which physical layer it landed on.
+   *
+   * For a FIELD subscription (`/cascade/theme.json/value`):
+   *   - watch the instance WRAPPER FILE on `base` and the bare-value file on
+   *     `userProvider` (see `mapSubscribePaths`);
+   *   - re-emit at the EXACT filter path so the bridged event matches what the
+   *     subscriber (PropBindSubscriber) asked for — SessionUserAFS then
+   *     re-prefixes the resolver-relative path back to `/instance/settings/...`.
+   *
+   * Two invariants make echo suppression + reset work:
+   *   1. ORIGIN PASSTHROUGH — `{ ...evt }` preserves `origin.sessionId`, so the
+   *      writer's own session is filtered out by PropBindSubscriber and a
+   *      different session still receives the patch. (The underlying write
+   *      carries origin only because `write()` now forwards `options.context`.)
+   *   2. TYPE NORMALIZATION — a user-layer DELETE (reset, D-f) is re-emitted as
+   *      `afs:write` because, from the cascade's point of view, the effective
+   *      value changed (reverted to the instance default); subscribers re-read
+   *      either way. We therefore drop the type filter on the underlying
+   *      subscription so deletes are not missed.
+   */
+  subscribe(filter: AFSEventFilter, callback: AFSEventCallback): AFSUnsubscribe;
+  setEventSink(sink: Parameters<NonNullable<AFSModule["setEventSink"]>>[0]): void;
+}
+//#endregion
+export { SettingsResolver, SettingsResolverOptions, SettingsScope };
+//# sourceMappingURL=settings-resolver.d.cts.map

package/dist/session/settings-resolver.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings-resolver.d.cts","names":[],"sources":["../../src/session/settings-resolver.ts"],"mappings":";;;;;KAiEY,aAAA;;KAEA,aAAA;AAAA,UAmBK,uBAAA;EA0jBqC;EAxjBpD,IAAA,EAAM,OAAA;EAgpBsD;EA9oB5D,YAAA,EAAc,SAAA;EA8uBqB;EA5uBnC,IAAA;EA4uBoD;EA1uBpD,SAAA;EA8xBY;;;;;;EAvxBZ,MAAA,GAAS,oBAAA;AAAA;AAAA,cAwKE,gBAAA,YAA4B,SAAA;EAAA,SAC9B,IAAA;EAAA,SACA,UAAA;EAAA,iBAEQ,IAAA;EAAA,iBACA,YAAA;EAAA,iBACA,IAAA;EAAA,iBACA,MAAA;EA8HH;EAAA,QA5HN,WAAA;EAsKI;;;;;;;;EAAA,QA7JJ,WAAA;EAiLQ;;;;;EAAA,iBA3KC,SAAA;cAEL,IAAA,EAAM,uBAAA;EA8NJ;;;;;;;EAAA,QA7MN,oBAAA;EAwV2B;EAAA,YArUvB,SAAA,CAAA;EAqUwC;;;;;;;;;;;EApT9C,WAAA,CAAY,QAAA,WAAmB,OAAA;EA4eF;EAtdnC,SAAA,CAAU,QAAA;EAsd0C;EAAA,YAjdxC,cAAA,CAAA;EAkgBN;EAAA,QA3fQ,aAAA;EA6fH;;;;;EAAA,QAzeG,aAAA;EAAA,YAsCF,QAAA,CAAA;EAAA,YAIA,cAAA,CAAA;EAkjBJ;EA5iBR,iBAAA,CAAkB,KAAA,EAAO,aAAA,GAAgB,aAAA;EA8jB5B;EAvjBb,OAAA,CAAQ,KAAA,EAAO,aAAA;EAujBY;EAhjB3B,QAAA,CAAS,KAAA,EAAO,aAAA;EAgjBgD;EAAA,QAviBxD,YAAA;EAslBU;EAAA,QA7kBV,oBAAA;EAAA,QAUA,QAAA;EAAA,QAKA,QAAA;EAAA,QAKM,mBAAA;EAqlBd;EAAA,QAtkBc,gBAAA;EAskBgB;EAAA,QAvjBhB,gBAAA;EAujBD;EAAA,QA9iBC,cAAA;EA8iB0D;;;;;;EAAA,QA7hBhE,mBAAA;;;;;;UAmBM,SAAA;;UAyDA,kBAAA;EAsBR,IAAA,CAAK,IAAA,UAAc,OAAA,GAAU,cAAA,GAAiB,OAAA,CAAQ,aAAA;;UAmE9C,SAAA;;;;;UAaA,SAAA;EAQR,IAAA,CAAK,IAAA,UAAc,OAAA,GAAU,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAgGtD,IAAA,CAAK,IAAA,UAAc,OAAA,GAAU,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAiDtD,KAAA,CACJ,IAAA,UACA,OAAA,EAAS,oBAAA,EACT,OAAA,GAAU,eAAA,GACT,OAAA,CAAQ,cAAA;;;;;;;UA0FH,qBAAA;;UAUA,YAAA;;;;;;;UAaA,oBAAA;EAkBF,MAAA,CAAO,IAAA,UAAc,OAAA,GAAU,gBAAA,GAAmB,OAAA,CAAQ,eAAA;;;;;;;;;;;;;;;;;;;;;;;;EA+ChE,SAAA,CAAU,MAAA,EAAQ,cAAA,EAAgB,QAAA,EAAU,gBAAA,GAAmB,cAAA;EA4B/D,YAAA,CAAa,IAAA,EAAM,UAAA,CAAW,WAAA,CAAY,SAAA;AAAA"}

package/dist/session/settings-resolver.d.mts

@@ -0,0 +1,177 @@
+import { SettingsSchemaHandle } from "./settings-schema-store.mjs";
+import { AFSDeleteOptions, AFSDeleteResult, AFSEventCallback, AFSEventFilter, AFSListOptions, AFSListResult, AFSModule, AFSReadOptions, AFSReadResult, AFSRoot, AFSStatOptions, AFSStatResult, AFSUnsubscribe, AFSWriteEntryPayload, AFSWriteOptions, AFSWriteResult } from "@aigne/afs";
+
+//#region src/session/settings-resolver.d.ts
+/** Where a field's value is *declared* (the schema-level cascade tag). */
+type SettingsScope = "instance" | "user" | "shared";
+/** The physical layer a given caller reads/writes for a scope. */
+type SettingsLayer = "instance" | "user";
+interface SettingsResolverOptions {
+  /** The Small World base (owns `/instance/settings/<rel>` wrapper files). */
+  base: AFSRoot;
+  /** The caller's per-user provider (`/user` backing), or null for anonymous. */
+  userProvider: AFSModule | null;
+  /** The caller's role, from `getCallerForSession().role`. Unknown → non-admin. */
+  role: string | undefined;
+  /** Owning session id — used for event origin tagging in P4. */
+  sessionId: string;
+  /**
+   * Derived schema index handle (settings-layering Phase 1c). When wired, the
+   * resolver lazily materializes the blocklet's package-schema scope on first
+   * settings access (idempotent, store-side single-flight). Phase 2 makes it
+   * the existence/schema source; until then resolution is unchanged.
+   */
+  schema?: SettingsSchemaHandle | null;
+}
+declare class SettingsResolver implements AFSModule {
+  readonly name: string;
+  readonly accessMode: "readwrite";
+  private readonly base;
+  private readonly userProvider;
+  private readonly role;
+  private readonly schema;
+  /** Memoized lazy ingest — at most one ensure() flight per session. */
+  private schemaReady;
+  /**
+   * Outcome of the lazy ingest. `ready` = the package declares settings and
+   * the derived index is consumable (STORE MODE: existence/schema come from
+   * the package index). `empty` = package declares none; `failed` = store
+   * unavailable; `unwired` = no handle. All non-`ready` states resolve in
+   * LEGACY MODE (instance rows define existence + schema) — the pre-Phase-2
+   * behavior, so blocklets without package settings keep working.
+   */
+  private schemaState;
+  /**
+   * Active render snapshots, insertion-ordered by `beginRender`. Ops resolve
+   * against the MOST RECENTLY begun snapshot (walks are sequential per
+   * render; concurrent renders each get their own immutable entry).
+   */
+  private readonly snapshots;
+  constructor(opts: SettingsResolverOptions);
+  /**
+   * Lazily materialize the package-schema scope (Phase 1c plumbing). Memoized
+   * per resolver (per session); the store's own single-flight + completion
+   * marker make cross-session work idempotent. BEST-EFFORT in Phase 1: a
+   * failed ingest logs and falls back to legacy resolution (Phase 2 will
+   * consume the scope for existence/schema and define the hard contract).
+   */
+  private ensureSchemaIngested;
+  /** STORE MODE — existence/schema from the derived package index (§1.4). */
+  private get storeMode();
+  /**
+   * Begin a render-scoped snapshot. Called by the auto-surface walk entry
+   * point (via `SessionUserAFS.beginRender` proxy) with a fresh `renderId`
+   * before walking; the resolver builds the WHOLE settings snapshot once
+   * (1× derived-index listEntries + instance/user override list + sparse
+   * reads) and serves every list/read of that render from memory.
+   *
+   * Phase 0: contract only — no-op. Phase 2 implements the snapshot builder.
+   * Idempotency contract: repeated `beginRender` with the same renderId and
+   * `endRender` without a matching begin are both safe no-ops.
+   */
+  beginRender(renderId: string): Promise<void>;
+  /** Discard the render snapshot for `renderId`. See {@link beginRender}. */
+  endRender(renderId: string): void;
+  /** The snapshot ops resolve against: the most recently begun, still active. */
+  private get activeSnapshot();
+  /** Bulk-read + parse the derived package schemas (1 store query). */
+  private loadSchemaMap;
+  /**
+   * Walk one override layer's tree and read every `.json` row. Sparse by
+   * design (converged rows: 0-5); legacy instances pay row-count reads ONCE
+   * per render — all in-process, replacing the per-field WS round-trips.
+   */
+  private loadLayerRows;
+  private get isAuthed();
+  private get isOwnerOrAdmin();
+  /** The physical layer this caller reads AND writes for the given scope. */
+  resolveWriteLayer(scope: SettingsScope): SettingsLayer;
+  /** Presentation hint: should this caller's form render the field at all? */
+  visible(scope: SettingsScope): boolean;
+  /** Capability hint + (P1) write-enforcement basis: may this caller edit it? */
+  editable(scope: SettingsScope): boolean;
+  /** Normalize an incoming resolver-relative path; reject traversal outright. */
+  private normalizeSub;
+  /** Translate an underlying layer path back into the resolver-relative space. */
+  private underlyingToRelative;
+  private baseRead;
+  private baseStat;
+  private loadInstanceWrapper;
+  /** Read the caller's bare override value, or undefined when absent/anonymous. */
+  private readUserOverride;
+  /** Parsed package schema for a field, or null (store mode only). */
+  private getSchemaWrapper;
+  /** Parsed raw instance row, or null when absent (never throws not-found). */
+  private getInstanceRow;
+  /**
+   * Reduce a raw instance row to its OVERRIDE-ONLY contribution (§2.D):
+   * `value` (when present) + keys explicitly written under `overrides`.
+   * A LEGACY full wrapper's flat schema keys are deliberately dropped —
+   * the package schema is authoritative (legacy-no-shadow).
+   */
+  private stripToOverrideOnly;
+  /**
+   * Load one field through the cascade. Returns null when the field does not
+   * exist — store mode: not in the derived package index (orphan instance
+   * rows are IGNORED, §5.4.5); legacy mode: no instance row.
+   */
+  private loadField;
+  /** Opaque version of the layer this caller would write — §3.7. */
+  private writeTargetVersion;
+  read(path: string, options?: AFSReadOptions): Promise<AFSReadResult>;
+  /** Store-mode directory existence: any package field lives under `sub`. */
+  private dirExists;
+  /**
+   * The full schema map (store mode): from the active snapshot when present,
+   * else one bulk store query — replacing the legacy per-field N+1 scope peek.
+   */
+  private schemaMap;
+  list(path: string, options?: AFSListOptions): Promise<AFSListResult>;
+  stat(path: string, options?: AFSStatOptions): Promise<AFSStatResult>;
+  write(path: string, content: AFSWriteEntryPayload, options?: AFSWriteOptions): Promise<AFSWriteResult>;
+  /**
+   * The ON-DISK override-only shape of an instance row: `{ value?, overrides? }`.
+   * Distinct from {@link stripToOverrideOnly} (the flattened READ-side
+   * contribution) — this preserves the nested `overrides` object so a write
+   * RMW keeps prior explicit schema-text edits.
+   */
+  private overrideOnlyDiskShape;
+  /** Assemble write options, omitting empties so providers see a clean shape. */
+  private writeOptions;
+  /**
+   * Read-modify-write the FULL instance wrapper so siblings
+   * (label/description/options/…) survive — the G0 regression guard. ifMatch
+   * (if supplied) is compared by the base provider against the wrapper version;
+   * context (if supplied) flows through so the emitted event carries origin.
+   */
+  private writeInstanceWrapper;
+  delete(path: string, options?: AFSDeleteOptions): Promise<AFSDeleteResult>;
+  /**
+   * Bridge instance-layer + user-layer change events into the
+   * `/instance/settings/...` namespace so propBind can react to a cascade write
+   * regardless of which physical layer it landed on.
+   *
+   * For a FIELD subscription (`/cascade/theme.json/value`):
+   *   - watch the instance WRAPPER FILE on `base` and the bare-value file on
+   *     `userProvider` (see `mapSubscribePaths`);
+   *   - re-emit at the EXACT filter path so the bridged event matches what the
+   *     subscriber (PropBindSubscriber) asked for — SessionUserAFS then
+   *     re-prefixes the resolver-relative path back to `/instance/settings/...`.
+   *
+   * Two invariants make echo suppression + reset work:
+   *   1. ORIGIN PASSTHROUGH — `{ ...evt }` preserves `origin.sessionId`, so the
+   *      writer's own session is filtered out by PropBindSubscriber and a
+   *      different session still receives the patch. (The underlying write
+   *      carries origin only because `write()` now forwards `options.context`.)
+   *   2. TYPE NORMALIZATION — a user-layer DELETE (reset, D-f) is re-emitted as
+   *      `afs:write` because, from the cascade's point of view, the effective
+   *      value changed (reverted to the instance default); subscribers re-read
+   *      either way. We therefore drop the type filter on the underlying
+   *      subscription so deletes are not missed.
+   */
+  subscribe(filter: AFSEventFilter, callback: AFSEventCallback): AFSUnsubscribe;
+  setEventSink(sink: Parameters<NonNullable<AFSModule["setEventSink"]>>[0]): void;
+}
+//#endregion
+export { SettingsResolver, SettingsResolverOptions, SettingsScope };
+//# sourceMappingURL=settings-resolver.d.mts.map

package/dist/session/settings-resolver.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings-resolver.d.mts","names":[],"sources":["../../src/session/settings-resolver.ts"],"mappings":";;;;;KAiEY,aAAA;;KAEA,aAAA;AAAA,UAmBK,uBAAA;EA0jBqC;EAxjBpD,IAAA,EAAM,OAAA;EAgpBsD;EA9oB5D,YAAA,EAAc,SAAA;EA8uBqB;EA5uBnC,IAAA;EA4uBoD;EA1uBpD,SAAA;EA8xBY;;;;;;EAvxBZ,MAAA,GAAS,oBAAA;AAAA;AAAA,cAwKE,gBAAA,YAA4B,SAAA;EAAA,SAC9B,IAAA;EAAA,SACA,UAAA;EAAA,iBAEQ,IAAA;EAAA,iBACA,YAAA;EAAA,iBACA,IAAA;EAAA,iBACA,MAAA;EA8HH;EAAA,QA5HN,WAAA;EAsKI;;;;;;;;EAAA,QA7JJ,WAAA;EAiLQ;;;;;EAAA,iBA3KC,SAAA;cAEL,IAAA,EAAM,uBAAA;EA8NJ;;;;;;;EAAA,QA7MN,oBAAA;EAwV2B;EAAA,YArUvB,SAAA,CAAA;EAqUwC;;;;;;;;;;;EApT9C,WAAA,CAAY,QAAA,WAAmB,OAAA;EA4eF;EAtdnC,SAAA,CAAU,QAAA;EAsd0C;EAAA,YAjdxC,cAAA,CAAA;EAkgBN;EAAA,QA3fQ,aAAA;EA6fH;;;;;EAAA,QAzeG,aAAA;EAAA,YAsCF,QAAA,CAAA;EAAA,YAIA,cAAA,CAAA;EAkjBJ;EA5iBR,iBAAA,CAAkB,KAAA,EAAO,aAAA,GAAgB,aAAA;EA8jB5B;EAvjBb,OAAA,CAAQ,KAAA,EAAO,aAAA;EAujBY;EAhjB3B,QAAA,CAAS,KAAA,EAAO,aAAA;EAgjBgD;EAAA,QAviBxD,YAAA;EAslBU;EAAA,QA7kBV,oBAAA;EAAA,QAUA,QAAA;EAAA,QAKA,QAAA;EAAA,QAKM,mBAAA;EAqlBd;EAAA,QAtkBc,gBAAA;EAskBgB;EAAA,QAvjBhB,gBAAA;EAujBD;EAAA,QA9iBC,cAAA;EA8iB0D;;;;;;EAAA,QA7hBhE,mBAAA;;;;;;UAmBM,SAAA;;UAyDA,kBAAA;EAsBR,IAAA,CAAK,IAAA,UAAc,OAAA,GAAU,cAAA,GAAiB,OAAA,CAAQ,aAAA;;UAmE9C,SAAA;;;;;UAaA,SAAA;EAQR,IAAA,CAAK,IAAA,UAAc,OAAA,GAAU,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAgGtD,IAAA,CAAK,IAAA,UAAc,OAAA,GAAU,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAiDtD,KAAA,CACJ,IAAA,UACA,OAAA,EAAS,oBAAA,EACT,OAAA,GAAU,eAAA,GACT,OAAA,CAAQ,cAAA;;;;;;;UA0FH,qBAAA;;UAUA,YAAA;;;;;;;UAaA,oBAAA;EAkBF,MAAA,CAAO,IAAA,UAAc,OAAA,GAAU,gBAAA,GAAmB,OAAA,CAAQ,eAAA;;;;;;;;;;;;;;;;;;;;;;;;EA+ChE,SAAA,CAAU,MAAA,EAAQ,cAAA,EAAgB,QAAA,EAAU,gBAAA,GAAmB,cAAA;EA4B/D,YAAA,CAAa,IAAA,EAAM,UAAA,CAAW,WAAA,CAAY,SAAA;AAAA"}