@davidorex/pi-context 0.30.0 → 0.31.0

package/dist/index.d.ts

@@ -1,4 +1,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { type RegistryAdditions } from "./context.js";
+import type { DispatchContext } from "./dispatch-context.js";
+import { type SchemaConflict } from "./schema-merge.js";
 /**
  * Thrown by `initProject` when an existing `.pi-context.json` bootstrap pointer
  * declares a different `contextDir` than the caller is requesting. Pre-FGAP-179
@@ -48,7 +51,125 @@ export interface InstallResult {
     updated: string[];
     skipped: string[];
     notFound: string[];
+    preserved: string[];
+    /**
+     * FGAP-029 safe re-sync (slice S4) — SCHEMA --update outcomes.
+     *   - `resynced`: an installed schema re-synced from the catalog where no
+     *     block-item migration was required (same `version` as installed — a
+     *     description-only / non-versioned drift — OR a version bump whose block
+     *     file is absent / holds zero items, so no items needed migrating).
+     *   - `migrated`: a version-bumped schema re-synced AND the populated block's
+     *     items forward-migrated through the shipped migration chain + re-validated
+     *     against the new schema (block re-written via the migration path).
+     *   - `blocked`: a version-bumped schema REFUSED — no shipped migration chain
+     *     reaches the catalog version, OR the migrated items would not validate
+     *     against the new schema. BOTH the schema file AND the block file are left
+     *     byte-unchanged (forward-migrate-or-refuse; never strand items under a
+     *     schema they fail).
+     */
+    resynced: string[];
+    migrated: string[];
+    blocked: string[];
 }
+/**
+ * One per-item validation failure mapped from an AJV `ErrorObject`, in the
+ * minimal shape the blocked-diagnostic surfaces consume (TASK-048 / FGAP-077).
+ * `itemId` is the failing block item's `id` when the AJV `instancePath` resolves
+ * to one (envelope-level errors leave it undefined); `instancePath` is AJV's raw
+ * JSON pointer; `keyword` + `message` carry the constraint that failed and its
+ * AJV text. The shape is deliberately minimal — no full `params` plumbing.
+ */
+export interface BlockValidationFailure {
+    itemId?: string;
+    instancePath: string;
+    keyword: string;
+    message: string;
+}
+/**
+ * Per-schema blocked-resync diagnostic detail (TASK-048 / FGAP-077). Carried by
+ * `simulateResyncOutcome` / `resyncSchema` on the blocked arms and surfaced via
+ * `UpdateResult.blockedDetail`, so a refused catalog-ahead resync reports WHY it
+ * refused — distinguishing a missing migration chain from items that fail the
+ * catalog schema, with the version pair and (for validation failures) the per-
+ * item failures naming id / field / constraint.
+ *   - `no-migration-chain`: no shipped chain reaches `to` from `from`; the
+ *     version pair is carried, `failures` omitted.
+ *   - `validation-failed`: the in-memory forward-migrate + re-validate threw; the
+ *     version pair is carried, `failures` lists the per-item constraint failures
+ *     (a single synthetic `{instancePath:"", keyword:"error", …}` entry when the
+ *     throw was not an AJV ValidationError).
+ */
+export interface BlockedDetail {
+    name: string;
+    reason: "no-migration-chain" | "validation-failed";
+    from?: string;
+    to?: string;
+    failures?: BlockValidationFailure[];
+    /**
+     * content_hash of the pinned pre-marker block bytes, set ONLY when the live
+     * update actually inscribed git-style failure markers into this schema's block
+     * file (TASK-052 / FGAP-081). `renderBlocked` keys its past-tense "markers were
+     * written INTO the block file" claim on this field's presence: a dryRun preview
+     * (writes nothing) and a `no-migration-chain` entry (never marked) leave it
+     * omitted, so the rendered guidance for those does not falsely claim a write.
+     */
+    premarker_hash?: string;
+}
+/**
+ * Read the verbatim bundled catalog `*.schema.json` body for a named
+ * block_kind. Resolves the catalog via the shared `resolveCatalog()` (same
+ * `samplesRoot` + `canonical_id`→`schema_path` map the installer and the drift
+ * detector use), then reads the catalog schema file's raw bytes. The returned
+ * `text` is the unparsed source (raw JSON Schema — properties/definitions/$id),
+ * NOT the `read-samples-catalog` projection, so an operator can diff it locally
+ * against the installed `<substrate>/schemas/<name>.schema.json` without
+ * touching node_modules (STORY-010 / FGAP-079, TASK-050).
+ *
+ * Read-only and substrate-independent: it touches only the package's bundled
+ * `samplesRoot` and takes no cwd, so no installed schema, block, or config is
+ * reachable from this path. Throws on an unknown kind, matching the unknown-kind
+ * throw idiom in validateBlockItemsAgainstCatalog / resolveConflict.
+ */
+export declare function readCatalogSchemaText(kindName: string): {
+    kind: string;
+    schemaPath: string;
+    text: string;
+};
+/**
+ * Validate ONE installed block's items against the CATALOG schema version,
+ * read-only (TASK-048 — FGAP-077). The standalone diagnostic underneath the
+ * `validate-block-items` op: it answers "would these items pass the catalog
+ * schema (after the shipped forward-migration, when the block lags the catalog
+ * version)?" WITHOUT writing anything — no schema overwrite, no block re-write, no
+ * migration registration.
+ *
+ * Resolution mirrors the catalog-ahead resync path so the diagnostic predicts the
+ * same pass/fail `resyncSchema` would reach:
+ *   - resolve the block_kind via `resolveCatalog().byId` (an unknown block throws
+ *     a field-named Error); read the catalog schema body off `samplesRoot`.
+ *   - load the installed block via `installedBlockDestPath` (a missing block file
+ *     throws field-named).
+ *   - when the block's declared envelope `schema_version` is a string differing
+ *     from the catalog `version` AND a shipped chain reaches the catalog version,
+ *     forward-migrate the block IN MEMORY through a FRESH registry seeded from the
+ *     substrate's existing decls + the chain's absent edges (deduped on
+ *     (schemaName, fromVersion)); otherwise validate as-is. No registry warming.
+ *   - `validate(catalogSchema, data, blockName)` in try/catch → pass:
+ *     `{valid:true, failures:[]}`; ValidationError → `{valid:false, failures}`
+ *     mapped against the (migrated) data; any other throw → a single synthetic
+ *     `{instancePath:"", keyword:"error", message:String(err)}` failure.
+ *
+ * Returns `{ block, from?, to?, valid, failures }`: `from`/`to` are the block's
+ * declared version and the catalog version (each undefined when unreadable).
+ * NEVER writes.
+ */
+export declare function validateBlockItemsAgainstCatalog(cwd: string, blockName: string): {
+    block: string;
+    from?: string;
+    to?: string;
+    valid: boolean;
+    failures: BlockValidationFailure[];
+};
 /**
  * /context install opt-in mechanism (DEC-0011). Reads config.installed_schemas
  * and config.installed_blocks, copies declared assets from the package
@@ -63,6 +184,417 @@ export interface InstallResult {
 export declare function installContext(cwd: string, options?: {
     overwrite?: boolean;
 }): InstallResult;
+/**
+ * One installed-schema's drift classification, produced by the read-only
+ * `checkStatus` detector. `state` summarizes the three-way comparison between
+ * the S2 install baseline (config.installed_from.assets[name].content_hash),
+ * the catalog's current schema file, and the currently-installed schema file:
+ *
+ *   - `in-sync`         — baseline === catalog-now === installed-now
+ *   - `catalog-ahead`   — catalog-now ≠ baseline, installed-now === baseline
+ *                         (the package shipped a newer schema; local copy
+ *                          still matches the baseline it was installed from)
+ *   - `locally-modified`— installed-now ≠ baseline, catalog-now === baseline
+ *                         (someone edited the installed schema on disk)
+ *   - `both-diverged`   — both catalog-now and installed-now ≠ baseline
+ *   - `no-baseline`     — no baseline recorded for this schema (pre-S2 install,
+ *                          or never installed) — drift is undecidable
+ *   - `missing-catalog` — the catalog source file is absent / unhashable
+ *   - `missing-installed` — the installed dest file is absent / unhashable
+ *
+ * `baseline_version` is the version captured in the baseline asset;
+ * `catalog_version` is the catalog schema file's own declared `version`;
+ * `installed_modified` is true when the installed file differs from the
+ * baseline content (covers locally-modified + both-diverged).
+ */
+export interface CheckStatusAsset {
+    name: string;
+    state: "in-sync" | "catalog-ahead" | "locally-modified" | "both-diverged" | "no-baseline" | "missing-catalog" | "missing-installed";
+    baseline_version?: string;
+    catalog_version?: string;
+    installed_modified?: boolean;
+    /**
+     * True for an asset whose CATALOG copy has moved past the install baseline
+     * (states `catalog-ahead` / `both-diverged`) — i.e. the installed schema is
+     * behind the catalog. Absent (undefined) on not-behind assets. (FGAP-078 /
+     * STORY-007: "report which installed schemas are behind the catalog".)
+     */
+    behind?: boolean;
+    /**
+     * The version gap for a `behind` asset (FGAP-078). `from`/`to` are the
+     * baseline and catalog versions (either may be undefined when a schema body
+     * omits `version`). `basis` distinguishes a declared version bump
+     * (`from !== to`, both present) from a content-only drift (same or
+     * undefined versions, yet the content hash moved — `catalog-ahead` is a hash
+     * comparison, so a behind asset can have an unchanged version string).
+     * Absent (undefined) on not-behind assets.
+     */
+    version_delta?: {
+        from?: string;
+        to?: string;
+        basis: "version-bump" | "content-only";
+    };
+}
+/**
+ * Result of the read-only `checkStatus` drift detector: a per-schema
+ * classification plus a state-keyed summary count (with a `total`). Writes
+ * nothing.
+ */
+export interface CheckStatusReport {
+    perAsset: CheckStatusAsset[];
+    summary: Record<CheckStatusAsset["state"], number> & {
+        total: number;
+    };
+}
+/**
+ * PURE-READ drift detector for `/context check-status` (FGAP-029 safe
+ * re-sync, slice S3). Compares, per installed schema, the S2 install baseline
+ * against the catalog's current schema file and the currently-installed schema
+ * file, classifies the drift, and RETURNS the report. Writes NOTHING anywhere —
+ * no config write, no file copy, no mkdir; only reads.
+ *
+ * For each `config.installed_schemas` entry:
+ *   - baseline      = config.installed_from?.assets?.[name]?.content_hash
+ *   - catalog-now   = computeFileContentHash(samplesRoot/<kind.schema_path>)
+ *                     (state `missing-catalog` when the source file is absent
+ *                      or unhashable)
+ *   - installed-now = computeFileContentHash(installedSchemaDestPath(destRoot,name))
+ *                     (state `missing-installed` when the dest file is absent
+ *                      or unhashable)
+ *
+ * Each file-hash read is wrapped in try/catch so a corrupt file degrades to a
+ * `missing-*` / diverged classification rather than throwing — mirroring S2's
+ * safety default. A schema whose name has no catalog block_kind is reported
+ * `missing-catalog`.
+ */
+export declare function checkStatus(cwd: string): CheckStatusReport;
+/**
+ * Render a `CheckStatusReport` (from the read-only `checkStatus` detector) as a
+ * scannable per-state grouping for `/context check-status`. Groups the
+ * affected schema names under each non-empty state, then a total line. Mirrors
+ * the install-handler `lines.push` style.
+ */
+export declare function renderCheckStatus(report: CheckStatusReport): string;
+/**
+ * The per-schema action plan produced by `updateContext` (FEAT-006 T1 — TASK-034 /
+ * DEC-0017). `updateContext` classifies every installed schema via the read-only
+ * `checkStatus` detector, then routes by drift state:
+ *
+ *   - `resynced` / `migrated`: a `catalog-ahead` schema (the package shipped a
+ *     newer schema; the local copy still matches the baseline it was installed
+ *     from) was brought current through the SAME `resyncSchema` path `/context
+ *     install --update` uses. `resyncSchema` reports `resynced` (same-version /
+ *     versionless drift, or a version bump with no items to migrate) vs
+ *     `migrated` (a version bump whose populated block forward-migrated +
+ *     re-validated); `updateContext` records the schema name under the
+ *     corresponding array. A `catalog-ahead` schema whose `resyncSchema` returns
+ *     `blocked` (no shipped chain, or migrated items fail the new schema) is
+ *     recorded under `blocked` — schema, block, and migrations.json all left
+ *     byte-unchanged (per `resyncSchema`'s blocked guarantee).
+ *   - `refused`: a `locally-modified` or `both-diverged` schema — the installed
+ *     file was edited on disk. This first increment (DEC-0017) REFUSES to
+ *     overwrite a locally-modified schema: no `resyncSchema` call, no copy, no
+ *     write of any kind for these. The schema name is recorded here so the
+ *     operator can reconcile; an automatic three-way merge is the deferred
+ *     follow-on (TASK-036), out of scope for T1.
+ *   - `reported`: a schema whose drift is undecidable or whose files are absent
+ *     (`no-baseline` / `missing-catalog` / `missing-installed`). Recorded with
+ *     its `state` (no write attempted) so the operator sees why it was not acted
+ *     on.
+ *   - `inSync`: an `in-sync` schema — already current, recorded as a no-action.
+ *
+ * `dryRun: true` performs NO writes (no `resyncSchema` call) — the action plan is
+ * computed from `checkStatus` alone, so the `resynced`/`migrated`/`blocked`
+ * arrays carry the schemas that WOULD be acted on (every `catalog-ahead` schema
+ * is reported under `resynced` in the preview, since the resync outcome is not
+ * computed without running it), and `refused`/`reported`/`inSync` are identical
+ * to the live run. Nothing on disk changes under `dryRun`.
+ */
+export interface UpdateResult {
+    /** Substrate-resolution / config-load failure (no schemas processed). */
+    error?: string;
+    /** When true, no writes were performed — the plan is a preview only. */
+    dryRun: boolean;
+    /** `catalog-ahead` schemas re-synced verbatim (same-version / no-item-migration). */
+    resynced: string[];
+    /** `catalog-ahead` schemas whose populated block forward-migrated + re-validated. */
+    migrated: string[];
+    /** `catalog-ahead` schemas whose resync was refused by `resyncSchema` (no safe migration). */
+    blocked: string[];
+    /**
+     * Per-schema blocked-resync diagnostic detail (TASK-048 — FGAP-077), one entry
+     * per name in `blocked`. Each carries the refusal `reason` (`no-migration-chain`
+     * — no shipped chain reaches the catalog version — vs `validation-failed` — the
+     * forward-migrated items fail the catalog schema), the installed→catalog version
+     * pair, and (for `validation-failed`) the per-item `failures` naming the failing
+     * item id, field (the `instancePath`), constraint `keyword`, and AJV `message`.
+     * Under `dryRun` this is the predicted detail; the live run reports the detail
+     * `resyncSchema` produced on refusal. The `blocked: string[]` list is unchanged.
+     */
+    blockedDetail: BlockedDetail[];
+    /** `locally-modified` / `both-diverged` schemas — refused, never overwritten (DEC-0017). */
+    refused: string[];
+    /**
+     * `locally-modified` / `both-diverged` schemas whose recorded base, local
+     * body, and catalog body merged conflict-free (TASK-036 — FEAT-006 T3). The
+     * merged body was written (live run) or validated only (`dryRun`).
+     */
+    merged: string[];
+    /**
+     * `locally-modified` / `both-diverged` schemas whose 3-way merge surfaced
+     * irreconcilable per-path disagreements (the merge declined to write); each
+     * entry carries the schema `name` + its `conflicts` for reconciliation.
+     */
+    conflicts: Array<{
+        name: string;
+        conflicts: SchemaConflict[];
+    }>;
+    /** `no-baseline` / `missing-catalog` / `missing-installed` schemas — reported, not acted on. */
+    reported: Array<{
+        name: string;
+        state: CheckStatusAsset["state"];
+    }>;
+    /** `in-sync` schemas — already current, no action. */
+    inSync: string[];
+    /**
+     * Catalog-new config-registry entries this run additively propagated into the
+     * substrate config (TASK-038 — FEAT-006 T5). Per registry, the identity-keyed
+     * ids brought current (`relation_types` / `block_kinds` by `canonical_id`,
+     * `invariants` / `lenses` by `id`). User-authored entries absent from the
+     * catalog, and existing entries whose body diverges from the catalog, are
+     * preserved untouched and never listed here (additive-only). Under `dryRun`
+     * the arrays report what WOULD be added; nothing is written.
+     */
+    registryAdditions: RegistryAdditions;
+    /**
+     * Migration declarations this run registered into the substrate's
+     * migrations.json (FGAP-050). A version-bump `catalog-ahead` re-sync registers
+     * the shipped catalog chain's not-already-present decls before migrating; each
+     * appears here as `{ schema, from, to }`. Mirrors `registryAdditions`: under
+     * `dryRun` this lists what WOULD be registered (computed read-only from the
+     * catalog chain minus the decls already on disk); nothing is written. A
+     * same-version resync or a `blocked` (rolled-back) outcome contributes nothing.
+     */
+    migrationsRegistered: Array<{
+        schema: string;
+        from: string;
+        to: string;
+    }>;
+}
+/**
+ * `/context update` engine (FEAT-006 T1 — TASK-034 / DEC-0017). Brings the
+ * installed substrate MODEL (schemas) current with the packaged catalog by
+ * consulting the read-only `checkStatus` drift detector per installed schema and
+ * routing each by its drift `state`:
+ *
+ *   - `in-sync`            → no-op (recorded under `inSync`).
+ *   - `catalog-ahead`      → re-sync via the EXISTING `resyncSchema` (the SAME
+ *                            call shape `/context install --update`'s schema loop
+ *                            uses for that asset: `resyncSchema(destRoot,
+ *                            samplesRoot, sourceFile, destFile, name)` with
+ *                            `sourceFile = samplesRoot/<kind.schema_path>` and
+ *                            `destFile = installedSchemaDestPath(destRoot,
+ *                            name)`). Its `resynced`/`migrated`/`blocked` outcome
+ *                            routes into the matching array.
+ *   - `locally-modified` /
+ *     `both-diverged`      → REFUSE-AND-REPORT: do NOT call `resyncSchema`, do NOT
+ *                            overwrite; record under `refused`. The first increment
+ *                            (DEC-0017) never clobbers a locally-edited schema; the
+ *                            three-way merge is deferred (TASK-036).
+ *                            [TASK-036 — FEAT-006 T3, now implemented]: the merge is no
+ *                            longer deferred. BASE is reconstructed from the baseline's
+ *                            content-addressed body (`getObject(destRoot,
+ *                            installed_from.assets[name].content_hash)`) and key/path-
+ *                            merged with OURS (installed file) + THEIRS (catalog file)
+ *                            via `mergeSchema`. Conflict-free → write via
+ *                            `writeSchemaCheckedForDir` (meta-validated; `dryRun`
+ *                            validates without writing), record under `merged`; any
+ *                            conflict → record `{name, conflicts}` under `conflicts`,
+ *                            write NOTHING; no retrievable base body / parse / merge /
+ *                            validation throw → fall back to `refused`. An auto-merged
+ *                            body is base-refreshed post-loop like a resync.
+ *   - `no-baseline` /
+ *     `missing-catalog` /
+ *     `missing-installed`  → record under `reported` (with the state) — undecidable
+ *                            or absent, not acted on.
+ *
+ * When `dryRun` is true NO writes occur: `checkStatus` is consulted and the action
+ * plan is computed, but `resyncSchema` is NOT invoked. For each `catalog-ahead`
+ * schema the dryRun arm calls `simulateResyncOutcome`, which mirrors
+ * `resyncSchema`'s decision arms 1:1 over an IN-MEMORY forward-migration +
+ * re-validation (FGAP-066 / TASK-046) and predicts the precise outcome bucket —
+ * `resynced` / `migrated` / `blocked` — the live path would land, so the schema is
+ * pushed onto `result[outcome]` rather than unconditionally onto `resynced`. The
+ * would-register migration decls it returns (the same FGAP-050 read-only set:
+ * catalog chain minus the decls already on disk; empty on a blocked prediction)
+ * are surfaced onto `migrationsRegistered` without writing. The live path mutates
+ * only via `resyncSchema` (the catalog-ahead branch) and surfaces the decls it
+ * appended onto `migrationsRegistered`; `installContext` and its install handler
+ * are NOT touched.
+ * Resolves the catalog / dest paths through the SAME `resolveCatalog` +
+ * `installedSchemaDestPath` helpers the installer + detector use.
+ */
+export declare function updateContext(cwd: string, { dryRun }?: {
+    dryRun?: boolean;
+}): UpdateResult;
+/**
+ * Stamp an in-memory schema `body` as the install baseline
+ * (`config.installed_from.assets[name]`) for one schema (TASK-037 — FEAT-006 T4
+ * / FGAP-069). The shared stamp mechanics extracted from
+ * `refreshBaselineForSchema`: compute the content_hash of `body`, store it into
+ * the content-addressed object store (`putObject`) under that hash, set
+ * `config.installed_from.assets[name] = { content_hash, version }` (refreshing
+ * `at`), and write the config. Self-contained + idempotent: it owns its config
+ * load + write. Returns the stamped `content_hash`, or `null` (no write) when
+ * the substrate dir is unresolvable or the config carries no `installed_from`.
+ *
+ * Two callers stamp via this: `refreshBaselineForSchema` (re-baselines the
+ * ON-DISK body — `update`'s post-loop refresh) and `resolveConflict` (advances
+ * the baseline to the CATALOG body so the next `update` re-derives a resolved
+ * schema as `locally-modified`, not a recurring conflict).
+ */
+export declare function stampBaselineFromBody(cwd: string, name: string, body: Record<string, unknown>, version: string): string | null;
+/**
+ * Re-stamp the install baseline (`config.installed_from.assets[name]`) for one
+ * schema from its CURRENT on-disk body (TASK-037 — FEAT-006 T4). Self-contained
+ * + idempotent. Used by `updateContext`'s post-loop refresh to re-baseline each
+ * brought-current schema (resynced / migrated / auto-merged) so a follow-up
+ * `/context check-status` reports it `in-sync`:
+ *
+ *   - returns `false` (no write) when the installed schema file is absent, OR
+ *     its freshly-computed `content_hash` already equals the recorded baseline
+ *     hash (a true no-op — nothing was reconciled / written).
+ *   - otherwise delegates the stamp to `stampBaselineFromBody` (object-store
+ *     put + `assets[name]` set + config write from the on-disk body + its
+ *     declared version) and returns `true`.
+ *
+ * This is a pure idempotent re-stamp action (re-stamps the on-disk body as the
+ * new baseline; false when the file is absent or its hash already equals the
+ * baseline). Mirrors `updateContext`'s post-loop refresh body for ONE name.
+ */
+export declare function refreshBaselineForSchema(cwd: string, name: string): boolean;
+/**
+ * Reconciliation-commit op (FGAP-069) — completes the caller-as-reconciler model
+ * end-to-end. After `update` surfaces a both-diverged schema CONFLICT, the
+ * calling agent reconciles the conflicting paths into a resolved body R and runs
+ * this op. It does two things atomically per call:
+ *
+ *   1. WRITES R, when a `schema` is supplied: parse-if-string (mirroring the
+ *      write-schema op's tolerant JSON-string handling) then
+ *      `writeSchemaCheckedForDir(destRoot, name, R, "replace", ctx)` (AJV
+ *      meta-validate + nested-id guard + atomic write). When `schema` is omitted
+ *      the current on-disk body is treated as already reconciled — no write.
+ *   2. ADVANCES the merge base to the CATALOG body (theirs): it reads the
+ *      catalog source schema, stamps it as the install baseline via
+ *      `stampBaselineFromBody`. This is the fix the bare write-schema lacks —
+ *      with the baseline advanced to the catalog, the next `update`'s 3-way
+ *      check resolves the schema as `locally-modified` (base === catalog ≠ R),
+ *      and `mergeSchema(base=catalog, ours=R, theirs=catalog)` takes R via the
+ *      `base === theirs → ours` rule → auto-merge, zero conflicts, R preserved.
+ *      Without this advance, the baseline stays at the original pre-conflict
+ *      body and `update` re-derives the SAME both-diverged conflict forever.
+ *
+ * Throws a clear error when the substrate dir is unresolvable, the config /
+ * catalog kind for `name` is missing, or the catalog source schema is absent —
+ * the base cannot be advanced without a catalog body to advance it to.
+ *
+ * Returns `{ schemaName, wroteSchema, baseAdvancedTo }`: `wroteSchema` is true
+ * iff a `schema` was supplied and written; `baseAdvancedTo` is the content_hash
+ * of the catalog body now stamped as the baseline.
+ */
+export declare function resolveConflict(cwd: string, name: string, schema?: unknown, ctx?: DispatchContext): {
+    schemaName: string;
+    wroteSchema: boolean;
+    baseAdvancedTo: string;
+};
+/**
+ * Blocked-resolution commit op (TASK-051 — FGAP-080) — the resolution half of
+ * the blocked-resync loop `update` opens. After `update` REFUSES a catalog-ahead
+ * resync (blocked) it persists a pending-blocked record pinning the TARGET
+ * catalog schema body (in the object store) + the migration chain reaching it.
+ * The calling agent then fixes the block's failing items (or widens the local
+ * schema) and runs THIS op to commit the resolution against the SAME pinned
+ * target the run blocked on — so a subsequent `update` converges (in-sync)
+ * instead of re-blocking.
+ *
+ * Flow:
+ *   1. Load the pending-blocked record; an absent entry for `name` throws a
+ *      field-named error (run `update` first to produce one).
+ *   2. Retrieve the pinned target schema body by its `target_hash` from the
+ *      object store; a missing object throws (the pin is the resolution contract).
+ *   3. Re-validate the CURRENT block against the PINNED target body: load the
+ *      installed block, forward-migrate its items IN MEMORY through the entry's
+ *      chain when the block's declared `schema_version` differs from the target
+ *      `to` version (a FRESH registry seeded existing-decls-first + the chain,
+ *      mirroring validateBlockItemsAgainstCatalog), then `validate`.
+ *   4. FAIL → return `{ resolved: false, failures }` and WRITE NOTHING — the
+ *      pending record stays intact so the caller can correct + retry.
+ *   5. PASS → in order: register the chain decls not already on disk (collecting
+ *      the registered set), write the target schema (replace), advance the
+ *      migrated block's `schema_version` envelope to `to` + persist it (skipping
+ *      the block write when it had no items — schema still written, base still
+ *      advanced, mirroring the live no-items handling), advance the merge base to
+ *      the target body, and clear the entry from pending-blocked.json (removing
+ *      the file when it becomes empty). Return `{ resolved: true,
+ *      registeredMigrations, baseAdvancedTo }`.
+ *
+ * Throws (no write) when the substrate dir is unresolvable, no pending entry
+ * names `name`, or the pinned target object is missing.
+ */
+export declare function resolveBlocked(cwd: string, name: string, ctx?: DispatchContext): {
+    schemaName: string;
+    resolved: false;
+    failures: BlockValidationFailure[];
+} | {
+    schemaName: string;
+    resolved: true;
+    registeredMigrations: Array<{
+        schema: string;
+        from: string;
+        to: string;
+    }>;
+    baseAdvancedTo: string | null;
+};
+/**
+ * Render an `UpdateResult["conflicts"]` set as a readable conflict report
+ * (TASK-037 — FEAT-006 T4 / FGAP-069) — the surface the `update` op + CLI hand
+ * to the CALLING agent, which reconciles each conflict into a resolved body and
+ * commits it via the `resolve-conflict` op (writes the body AND advances the
+ * merge base to the catalog so `update` stops re-reporting it; no subordinate
+ * resolver is spawned). Mirrors `renderCheckStatus`'s grouping
+ * style: one section per conflicting schema `name`, then each irreconcilable
+ * `{ path, base, ours, theirs }` with its three values JSON-compacted for a
+ * side-by-side scan, then a trailing guidance line stating how to apply a
+ * reconciliation. Pure: no I/O, no writes.
+ */
+export declare function renderConflicts(conflicts: UpdateResult["conflicts"]): string;
+/**
+ * Render the per-schema blocked-resync diagnostic (TASK-048 — FGAP-077) as a
+ * readable report the CLI surfaces below `update`'s output when a catalog-ahead
+ * resync was refused. One section per blocked schema `name`:
+ *   - header `blocked: <name> (<from> -> <to>)` (the installed→catalog version
+ *     pair; `?` substitutes a missing version).
+ *   - `no-migration-chain` → one line `no migration chain reaches <to> from
+ *     <from>`.
+ *   - `validation-failed` → one line per failing item, naming the item id (or the
+ *     `instancePath` when no id resolved), the field (the tail of `instancePath`),
+ *     and the constraint phrased keyword-aware — MIRRORING the CLI's
+ *     `formatAjvError` keyword switch (required / type / enum / additionalProperties
+ *     fall through to the raw message), reproduced here rather than imported to
+ *     avoid a pi-context → pi-context-cli dependency cycle (render.ts imports this
+ *     package). A failure carrying no AJV `keyword` mapping prints its raw message.
+ *
+ * TASK-052 / FGAP-081: a LIVE `update` that blocks a `validation-failed` resync
+ * inscribes git-style failure markers INTO the block file at the offending items —
+ * and ONLY then does the trailing guidance claim, in the past tense, that markers
+ * "were written INTO the block file(s)". That claim is keyed on the per-entry
+ * `premarker_hash` (set only when markers were actually inscribed): a dryRun preview
+ * writes nothing and a `no-migration-chain` entry is never marked, so neither carries
+ * `premarker_hash` — for those the report keeps each entry's reason line + neutral
+ * fix-then-resolve guidance WITHOUT the past-tense write claim. In all cases the
+ * schema + `migrations.json` stay byte-unchanged. Pure: no I/O, no writes.
+ */
+export declare function renderBlocked(blockedDetail: BlockedDetail[]): string;
 /**
  * Bootstrap a new substrate dir + flip the pointer in one operation. The
  * shared engine behind `/context switch -c <new-dir>` and the
@@ -148,9 +680,11 @@ export declare function archiveSubstrate(cwd: string, targetDir: string): {
 };
 declare const extension: (pi: ExtensionAPI) => void;
 export default extension;
+export { mergeCatalogRegistries, type RegistryAdditions } from "./context.js";
 export { contextRegistryPath, invalidateRegistry, loadRegistry, REGISTRY_FILE_VERSION, type RegistryEntry, type RegistryFile, registerSubstrate, resolveAlias, resolveSubstrateDir, writeRegistry, } from "./context-registry.js";
 export type { CompleteTaskResult, ItemLocation, ResolvedRef, ResolveStatus } from "./context-sdk.js";
 export { blockStructure, buildIdIndex, CONTEXT_BLOCK_TYPES, completeTask, findAppendableBlocks, resolveItemById, resolveRef, schemaInfo, schemaVocabulary, } from "./context-sdk.js";
 export { type RenameKind, type RenameReport, renameCanonicalId } from "./rename-canonical-id.js";
 export { listRoadmaps, loadRoadmap, type PhaseSpec, type PhaseStatus, type PhaseView, type RoadmapSpec, type RoadmapView, renderRoadmap, resolveStatusVocabulary, rollupPhaseStatus, topoSort, validateRoadmaps, } from "./roadmap-plan.js";
+export type { SchemaConflict } from "./schema-merge.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAA2B,MAAM,iCAAiC,CAAC;AAqM7F;;;;;;;;;;;;;;GAcG;AACH,qBAAa,wBAAyB,SAAQ,KAAK;IAClD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;gBACf,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;CAU/C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CA0DrG;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC7B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,GAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG,aAAa,CAqFhG;AAuHD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG;IAAE,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAyCjH;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,IAAI,CAY7F;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CA2BlG;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,CAAC,CAqCtF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAyC7F;AAsFD,QAAA,MAAM,SAAS,GAAI,IAAI,YAAY,SAyRlC,CAAC;AAEF,eAAe,SAAS,CAAC;AAEzB,OAAO,EACN,mBAAmB,EACnB,kBAAkB,EAClB,YAAY,EACZ,qBAAqB,EACrB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,iBAAiB,EACjB,YAAY,EACZ,mBAAmB,EACnB,aAAa,GACb,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EAAE,kBAAkB,EAAE,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAErG,OAAO,EACN,cAAc,EACd,YAAY,EACZ,mBAAmB,EACnB,YAAY,EACZ,oBAAoB,EACpB,eAAe,EACf,UAAU,EACV,UAAU,EACV,gBAAgB,GAChB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,YAAY,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AACjG,OAAO,EACN,YAAY,EACZ,WAAW,EACX,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,aAAa,EACb,uBAAuB,EACvB,iBAAiB,EACjB,QAAQ,EACR,gBAAgB,GAChB,MAAM,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAA2B,MAAM,iCAAiC,CAAC;AAI7F,OAAO,EASN,KAAK,iBAAiB,EAItB,MAAM,cAAc,CAAC;AAYtB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAkB7D,OAAO,EAAe,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAC;AA6KrE;;;;;;;;;;;;;;GAcG;AACH,qBAAa,wBAAyB,SAAQ,KAAK;IAClD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;gBACf,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;CAU/C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CA0DrG;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC7B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB;;;;;;;;;;;;;;OAcG;IACH,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,sBAAsB;IACtC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,aAAa;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,oBAAoB,GAAG,mBAAmB,CAAC;IACnD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,sBAAsB,EAAE,CAAC;IACpC;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACxB;AAwOD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAS1G;AAkOD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,gCAAgC,CAC/C,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,MAAM,GACf;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,sBAAsB,EAAE,CAAA;CAAE,CA2DnG;AA2ND;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,GAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG,aAAa,CAqNhG;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,WAAW,gBAAgB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EACF,SAAS,GACT,eAAe,GACf,kBAAkB,GAClB,eAAe,GACf,aAAa,GACb,iBAAiB,GACjB,mBAAmB,CAAC;IACvB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B;;;;;OAKG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;;;;;OAQG;IACH,aAAa,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,EAAE,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,cAAc,GAAG,cAAc,CAAA;KAAE,CAAC;CACvF;AAED;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IACjC,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC,gBAAgB,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,GAAG;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;CACvE;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,CAgH1D;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM,CAkCnE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,WAAW,YAAY;IAC5B,yEAAyE;IACzE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,wEAAwE;IACxE,MAAM,EAAE,OAAO,CAAC;IAChB,qFAAqF;IACrF,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,qFAAqF;IACrF,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,8FAA8F;IAC9F,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB;;;;;;;;;OASG;IACH,aAAa,EAAE,aAAa,EAAE,CAAC;IAC/B,4FAA4F;IAC5F,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB;;;;OAIG;IACH,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB;;;;OAIG;IACH,SAAS,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,cAAc,EAAE,CAAA;KAAE,CAAC,CAAC;IAChE,gGAAgG;IAChG,QAAQ,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;KAAE,CAAC,CAAC;IACpE,sDAAsD;IACtD,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB;;;;;;;;OAQG;IACH,iBAAiB,EAAE,iBAAiB,CAAC;IACrC;;;;;;;;OAQG;IACH,oBAAoB,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC1E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,MAAc,EAAE,GAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG,YAAY,CA6UtG;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CACpC,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,EAAE,MAAM,GACb,MAAM,GAAG,IAAI,CAiBf;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAY3E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,eAAe,CAC9B,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,OAAO,EAChB,GAAG,CAAC,EAAE,eAAe,GACnB;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,OAAO,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,CA2CtE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,cAAc,CAC7B,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,GAAG,CAAC,EAAE,eAAe,GAEnB;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,KAAK,CAAC;IAAC,QAAQ,EAAE,sBAAsB,EAAE,CAAA;CAAE,GAC3E;IACA,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,IAAI,CAAC;IACf,oBAAoB,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC1E,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B,CAgJH;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,YAAY,CAAC,WAAW,CAAC,GAAG,MAAM,CAoB5E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,aAAa,CAAC,aAAa,EAAE,aAAa,EAAE,GAAG,MAAM,CAsCpE;AAqID;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG;IAAE,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAyCjH;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,IAAI,CAY7F;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CA2BlG;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,CAAC,CAqCtF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAyC7F;AAsFD,QAAA,MAAM,SAAS,GAAI,IAAI,YAAY,SAiTlC,CAAC;AAEF,eAAe,SAAS,CAAC;AAKzB,OAAO,EAAE,sBAAsB,EAAE,KAAK,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAC9E,OAAO,EACN,mBAAmB,EACnB,kBAAkB,EAClB,YAAY,EACZ,qBAAqB,EACrB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,iBAAiB,EACjB,YAAY,EACZ,mBAAmB,EACnB,aAAa,GACb,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EAAE,kBAAkB,EAAE,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAErG,OAAO,EACN,cAAc,EACd,YAAY,EACZ,mBAAmB,EACnB,YAAY,EACZ,oBAAoB,EACpB,eAAe,EACf,UAAU,EACV,UAAU,EACV,gBAAgB,GAChB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,YAAY,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AACjG,OAAO,EACN,YAAY,EACZ,WAAW,EACX,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,aAAa,EACb,uBAAuB,EACvB,iBAAiB,EACjB,QAAQ,EACR,gBAAgB,GAChB,MAAM,mBAAmB,CAAC;AAK3B,YAAY,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC"}