@issuegraph/editor 0.4.0 → 0.10.0

package/dist/workspace/render.d.ts

@@ -49,17 +49,30 @@
  * `styles.ts` writes structure against its custom properties.
  */
 import { type Theme, type ViewerDocument } from '@issuegraph/viewer';
-import type { ProjectedEdge } from '@issuegraph/store';
+import type { EdgeId, InvalidCode, MutationId, ProjectedEdge } from '@issuegraph/store';
 import type { AuditInput } from '../audit/findings.ts';
+import { type CreateDraft } from '../create/draft.ts';
+import type { Point } from '../create/placement.ts';
 import { type AuditOverlay } from '../audit/surface.ts';
 import { type ScaleState } from '../scale/commands.ts';
 import { type InspectorView } from './inspector.ts';
 import { type RailWindow, type RailWindowOptions } from './rail.ts';
+import { type ConflictDiff } from './recovery.ts';
 import { type WorkspaceSelection } from './selection.ts';
 /** The four fixed positions. A closed union, which is what keeps `zone` safe. */
 export declare const ZONES: readonly ["header", "rail", "canvas", "inspector"];
 export type Zone = (typeof ZONES)[number];
 export interface WorkspaceWords {
+    /**
+     * The panel's own heading — frame 17a's `INSPECTOR`.
+     *
+     * UNCONDITIONAL, and that is what it is for: the zone used to begin with
+     * whatever the selection happened to resolve to, so a reader who had selected
+     * nothing met a bare sentence in an unnamed column. The caps are the
+     * stylesheet's, as they already are for `WHY RANK` and `RELATIONSHIPS`, so
+     * the word supplied here reads as a word.
+     */
+    readonly inspector: string;
     /** Shown in the inspector when nothing is selected. */
     readonly nothingSelected: string;
     /**
@@ -74,6 +87,323 @@ export interface WorkspaceWords {
     readonly clearSelection: string;
     /** Names the relationships list. */
     readonly relationships: string;
+    /**
+     * §17a's `WHY RANK n` heading, without the number.
+     *
+     * THE NUMBER IS APPENDED, NOT INTERPOLATED INTO A HOST TEMPLATE. A rank is
+     * the one part of this heading the package knows and the host does not, and
+     * a `{n}` placeholder would make every host reimplement the substitution —
+     * which is how a package that refuses to invent English ends up shipping a
+     * tiny template language instead.
+     */
+    readonly whyRank: string;
+    /**
+     * The same heading for a HELD slot, which has no rank to name.
+     *
+     * A held slot's rank is `null` by construction (`@issuegraph/derive` assigns
+     * `ready ? (rank += 1) : null`), so "why rank —" would be a heading about a
+     * position that does not exist. The design's own §16d ruling is the same one:
+     * a held unit prints the em dash rather than a number.
+     */
+    readonly whyHeld: string;
+    /**
+     * Joins the rest of a together unit: §17a ends *"then worked with #514 as one
+     * unit"*, and this is that phrase minus the members, which the package names.
+     */
+    readonly workedAsOneUnit: string;
+    /**
+     * Stated when the subject has no relationships at all.
+     *
+     * A STATED EMPTY IS NOT THE SAME AS AN ABSENT LIST. The panel used to draw
+     * the `RELATIONSHIPS` heading and then nothing under it, which reads as a
+     * list that failed to load rather than as an issue that is genuinely
+     * unrelated to everything — and "this issue is connected to nothing" is one
+     * of the more actionable things a grooming surface can say.
+     */
+    readonly noRelationships: string;
+    /**
+     * The control that begins a relationship from the selected issue — frame
+     * 17a's `+ add`, publishing `add`.
+     *
+     * MOVED HERE FROM `MountWords`, where it was while the mount drew the button.
+     * `renderWorkspace` is the published surface and the panel is now what draws
+     * it, so a host rendering the markup without mounting gets the control rather
+     * than a panel that can only be read. `MountWords` extends this, so the mount
+     * still reads the same field and no host supplies two.
+     */
+    readonly addRelationship: string;
+    /**
+     * The control that abandons a draft — frame 17b's escape hatch beside the
+     * numbered kind list, publishing `cancel`.
+     *
+     * MOVED HERE FROM `MountWords` WITH THE STEP IT BELONGS TO. The kind list and
+     * the control that withdraws from it are one affordance; leaving the cancel
+     * in host chrome while the list moved into the package would have split a
+     * control group across two layers, and a draft the reader cannot abandon with
+     * a pointer is the failure `create/keys.ts` names for the keyboard. The
+     * mount's target-search step still reads this field, through the extension.
+     */
+    readonly cancel: string;
+    /**
+     * Names the issue a live draft was begun from, when that is not the panel's
+     * subject — "relating from", read before the reference the package supplies.
+     *
+     * IT EXISTS BECAUSE THE TWO CAN DIVERGE AND THE DRAFT MUST STILL BE
+     * CANCELLABLE. See {@link addStepSpec}: a draft begun by `R` on a together
+     * unit's non-lead member, or one outlived by a change of selection, leaves
+     * the kind step live under a panel headed by a different issue. The step is
+     * drawn anyway — it carries the only pointer cancel there is — so it has to
+     * say whose it is, and the package invents that phrase no more readily than
+     * it invents {@link WorkspaceWords.workedAsOneUnit}. The REFERENCE is the
+     * package's, appended as its own element, so a host writes a phrase and never
+     * a template.
+     */
+    readonly relatingFrom: string;
+    /**
+     * The accessible name of a row's remove control — the `✕` in frame 17a's
+     * right-hand slot.
+     *
+     * ROW-INDEPENDENT WORDING. Which relationship it removes is in the markup
+     * (`data-ig-target`) and in the row the button sits on, not in this string, so
+     * a host writing "remove #488" here would be wrong on every other row.
+     *
+     * DISTINCT FROM `MountWords.deleteRelationship`, which names a different
+     * control: that is the mount's labelled button for the one SELECTED edge, and
+     * this is a glyph button repeated once per row. A glyph carries no name of its
+     * own — see {@link relationshipSpec} — so the two cannot share one string
+     * without one of them reading wrongly.
+     */
+    readonly remove: string;
+    /**
+     * The right-hand marker on an incoming row — frame 17a's `inbound`.
+     *
+     * IT IS A STATED FACT, NOT A MISSING CONTROL. An inbound edge's field lives in
+     * the OTHER issue's body, so this panel's subject cannot declare it away; the
+     * slot says which relationship this is rather than leaving a gap where the
+     * other rows have a `✕`.
+     */
+    readonly inbound: string;
+    /**
+     * The control that reverses a directed relationship — frame 17b's `⇅ flip`.
+     *
+     * MOVED HERE FROM `PickerWords` WITH THE CONTROL ITSELF, on the same rule
+     * that brought `addRelationship` and `cancel` down from `MountWords`: the
+     * surface that draws a control owns the word for it, so a host rendering the
+     * markup without mounting gets the affordance rather than a panel it can only
+     * read. §17b calls direction “the single most common encoding mistake”, which
+     * made this the worst control to have reachable from one rendering path only.
+     *
+     * IT IS NOT #144's MOVE, AND THE DIFFERENCE IS VISIBLE TO EVERY HOST.
+     * `addRelationship` travelled between two interfaces in one `extends` chain,
+     * so `words.addRelationship` read the same before and after. `MountWords`
+     * holds the picker's vocabulary in a NESTED field, so this word's path
+     * changed: `words.picker.flip` became `words.flip`.
+     *
+     * ROW-INDEPENDENT WORDING, exactly as {@link WorkspaceWords.remove} is. Which
+     * relationship it reverses is the selected row it sits in, never this string.
+     */
+    readonly flip: string;
+    /**
+     * Why the store refused an edit, keyed by its code.
+     *
+     * TOTAL OVER `InvalidCode`, so a code the store adds is a compile error in
+     * every host rather than a capsule that renders blank on the one refusal
+     * nobody anticipated. The store's own `InvalidReason.message` is deliberately
+     * not used: it is one sentence in one language chosen by the layer that
+     * detected the refusal, and `overlay/grammar.ts` already records that an
+     * invalid edge's sentence is the host's, keyed off the code.
+     */
+    readonly refusals: Readonly<Record<InvalidCode, string>>;
+    /**
+     * §17b's recovery cards, in the host's own words.
+     *
+     * `retry` AND `retryOnLatest` ARE TWO WORDS BECAUSE THEY ARE TWO CALLS. §17b
+     * names the failed affordance "retry" and the conflict affordance "retry on
+     * latest", and they reach `store.retry` and `store.retryOnLatest`
+     * respectively — the second of which re-reads and ADOPTS the upstream
+     * document as the new base before re-dispatching. One string for both would
+     * make one card lie about what pressing it does, and it would be the card
+     * whose consequence most needs stating.
+     */
+    readonly recovery: RecoveryWords;
+}
+export interface RecoveryWords {
+    /** Names the state on a failed card. */
+    readonly failed: string;
+    /** Names the state on a conflicted card. */
+    readonly conflict: string;
+    readonly viewDiff: string;
+    /** `failed` → `store.retry`. */
+    readonly retry: string;
+    /** `conflict` → `store.retryOnLatest`, which adopts upstream as the new base. */
+    readonly retryOnLatest: string;
+    readonly discardMine: string;
+    /** Heads the edges the held document has and the reader's does not. */
+    readonly upstreamOnly: string;
+    /** Heads the reader's own unlanded edit, where it ADDS a relationship. */
+    readonly mineOnly: string;
+    /** Heads the reader's own unlanded edit, where it REMOVES one. */
+    readonly mineRemoved: string;
+    /** Heads relationships both sides hold pointing opposite ways. */
+    readonly carrierReversed: string;
+    /** Heads the issues the two documents disagree about. */
+    readonly issuesChanged: string;
+    /** Shown when the diff has nothing to show on THIS panel. */
+    readonly diffEmpty: string;
+    /**
+     * Why a `retry on latest` could not even read.
+     *
+     * The store's refresh is half of one operation: when it fails the record is
+     * restored verbatim and nothing is dispatched, so without this the button
+     * reads as dead on exactly the failure the store went to trouble to make
+     * observable.
+     */
+    readonly retryFailed: string;
+    /**
+     * Heads the region for recoveries with no panel to sit on.
+     *
+     * See {@link WorkspaceRecovery.carrier}: a write about issues this backlog
+     * does not hold has no panel, and dropping it would leave the reader's work
+     * unrecoverable.
+     */
+    readonly unplaced: string;
+}
+/**
+ * One unsettled write the reader can still act on: §17b's `failed` and
+ * `conflict`.
+ *
+ * NARROW FOR THE REASON {@link WorkspaceRefusal} IS, and shaped the same way.
+ * The whole write ledger is the larger surface this deliberately is not: a
+ * `WriteRecord` carries a `Mutation` and, on a conflict, an entire second
+ * `GraphDocument`, none of which a renderer can draw. What a card needs is the
+ * state, the reason or the difference, and which panel states it.
+ *
+ * A UNION, BECAUSE THE TWO STATES CARRY DIFFERENT FACTS. `WriteRecord` is
+ * already a union on this exact line. Two optionals would admit a conflict with
+ * no diff and a failure with one, and the renderer would need a runtime guard
+ * for a case the type can refuse outright.
+ *
+ * NO `phantom` EQUIVALENT, and the absence is deliberate rather than an
+ * oversight. {@link WorkspaceRefusal.phantom} exists because a refusal either
+ * JOINS a relationship row or REPLACES it, and getting that wrong deletes a
+ * removable relationship from the panel. A recovery card is its own element in
+ * its own region and replaces nothing, so the question does not arise.
+ */
+export type WorkspaceRecovery = {
+    readonly kind: 'failed';
+    readonly mutationId: MutationId;
+    readonly edgeId: EdgeId;
+    readonly carrier: string | null;
+    /**
+     * The adapter's own sentence, verbatim.
+     *
+     * NOT KEYED OFF A CODE, and the asymmetry with {@link
+     * WorkspaceWords.refusals} is the argument. The store's refusal codes are
+     * a CLOSED set the store owns, so a host can be made total over them. An
+     * adapter's failure is an open one — a status, a rate limit, a network
+     * message — and there is no code to key on, so the sentence travels.
+     */
+    readonly reason: string;
+} | {
+    readonly kind: 'conflict';
+    readonly mutationId: MutationId;
+    readonly edgeId: EdgeId;
+    readonly carrier: string | null;
+    /** Both sides, held apart. See `recovery.ts`. */
+    readonly diff: ConflictDiff;
+    /**
+     * Why the last refresh could not read, or `null`.
+     *
+     * A `retry on latest` whose READ fails restores the record exactly as it
+     * was and dispatches nothing — the conflict keeps its held document so it
+     * can still be compared against. Without this the card re-renders
+     * identically and the button reads as dead.
+     */
+    readonly refreshError: string | null;
+};
+/**
+ * One refused edit, as the panel needs it: which edge, and why.
+ *
+ * NARROW ON PURPOSE, AND THE NARROWNESS IS THE ARGUMENT. `WorkspaceOptions.projected`
+ * already carries every edge's states, and `invalid` is among them — but a
+ * state says an edge was refused and never says why, because the code lives on
+ * `WriteRecord.reason`, which reaches no renderer. The alternative was to hand
+ * the panel the whole write ledger, which is the input #137's conflict cards
+ * need and is a much larger surface: both versions of a conflicted body, the
+ * upstream document, the retry and discard affordances. This is one code per
+ * edge id, derivable in a shell from what the store already publishes, and
+ * nothing here is blocked on that larger shape.
+ */
+export interface WorkspaceRefusal {
+    readonly edgeId: EdgeId;
+    readonly code: InvalidCode;
+    /**
+     * The issue whose panel states this refusal.
+     *
+     * THE EDIT'S OWN SUBJECT, DECIDED BY WHOEVER MADE THE EDIT. This panel used
+     * to work it out for itself, by asking whether the refused edge's identity
+     * named the issue on show — a derivation entirely separate from the one that
+     * produced the subject, and free to disagree with it. It did, three times
+     * over: an unfiltered orphan branch drew every refusal on every panel; a
+     * retype whose projection hid the edge the panel was filtered to left the
+     * panel with no subject and the reason nowhere; and a draft begun from a
+     * together-unit partner produced an edge naming the partner while
+     * `inspectorView` had canonicalized the panel onto the slot's lead, so
+     * nothing matched. None of the three is a question this renderer can answer
+     * from an identity, because none of them is about the identity.
+     *
+     * A MOUNT KNOWS IT WITHOUT GUESSING, BECAUSE IT WROTE IT DOWN. `editCarrier`
+     * in `host.ts` answers it — for a create from a draft, for a retype or flip
+     * whose produced identity differs from the one the reader named, and for a
+     * delete — and `mountWorkspace` asks it as the edit goes OUT, while the
+     * document still holds the relationship, then keeps the answer against the
+     * write. It cannot be asked again afterwards: by the time a refusal comes
+     * back a sibling write may have removed the edge, and an identity records
+     * which two issues a relationship was between and never which of them
+     * declared it. A host rendering without `mountWorkspace` states the same fact
+     * the same way: whichever issue's panel it wants the refusal read on, decided
+     * when it made the edit.
+     *
+     * NOT DERIVABLE FROM {@link WorkspaceRefusal.edgeId}, which is why it is a
+     * second field rather than a lookup. `unknown-issue` names an issue the
+     * document does not hold; `unknown-edge` names an edge it does not hold; and
+     * a together unit's panel is headed by a key the edge may never mention.
+     */
+    readonly carrier: string;
+    /**
+     * Whether the edge this refusal marks exists only because the refusal does.
+     *
+     * NOT EVERY REFUSAL IS ABOUT AN EDIT THAT LEFT NO TRACE, and reading them as
+     * if they were deleted a relationship the reader still has. Three of the
+     * store's codes mark an edge that is already LANDED — measured against the
+     * store rather than reasoned from the code list: `duplicate-edge` (a create
+     * of a relationship that exists; `project` folds the phantom onto the real
+     * edge), and `unchanged-kind` and `symmetric-edge` (a retype or flip whose
+     * result has the identity it started from, so `edgeChangeFor` marks the
+     * original rather than swapping it). `cardinality` looks like a fourth and is
+     * not: through a create it marks the edge it would have made, and through a
+     * retype it marks the edge it would have BECOME — a phantom either way, with
+     * the original hidden — which is exactly why this is asked of the document
+     * rather than keyed off a list of codes. With the capsule REPLACING the row
+     * for all of them, telling a reader "this relationship is already declared"
+     * removed the declared relationship's row from the panel, remove control
+     * included — so the one message they were given was contradicted by the list
+     * beside it, and nothing on the surface could undo the edge they had just
+     * been told about.
+     *
+     * TRUE MEANS THE ROW IS THE REFUSAL. A refused CREATE of a genuinely new
+     * relationship draws as a capsule in the row it would have been: there is no
+     * relationship to operate, and a `select-edge` and a `✕` on it would offer to
+     * remove something that was never added. False means the relationship is
+     * real, so the row stands and the reason is attached to it.
+     *
+     * REQUIRED, BECAUSE NEITHER DEFAULT IS SAFE. Defaulted to `true` the panel
+     * eats real rows; defaulted to `false` it draws a live remove control for an
+     * edge the document does not have. A host derives it in one line — the
+     * refused id is in `snapshot.landed` or it is not — and the store's own
+     * projection is where both halves already come from.
+     */
+    readonly phantom: boolean;
 }
 export interface WorkspaceOptions {
     /**
@@ -115,8 +445,79 @@ export interface WorkspaceOptions {
      * The store's projection, for the canvas to draw each edge's write states.
      * See `ScaleLadderOptions.projected`; the workspace forwards it and reads
      * none of it, because the rail and the inspector draw no line to overlay.
+     *
+     * AND IT IS NOT WHERE THE INSPECTOR'S REFUSALS COME FROM, which is worth
+     * saying here because it is the obvious place to look. A `ProjectedEdge`
+     * carries `states` and `writes` — so it says an edge is `invalid` and never
+     * says why. The code is on the write record, and the panel takes it through
+     * {@link WorkspaceOptions.refusals}.
      */
     readonly projected?: readonly ProjectedEdge[] | undefined;
+    /**
+     * The create draft in flight, so the panel can draw the step the reader is on.
+     *
+     * §17b's inspector path is `+ add` → kind → target, and `create/draft.ts`
+     * makes `begin` RESET the kind and the target on purpose. An always-visible
+     * kind list would therefore let a reader fill a slot that the next `+ add`
+     * silently discards, so the list is drawn only while a draft is live —
+     * which the panel cannot know without being told.
+     *
+     * Absent means idle, which is the state a host that has no create path is in.
+     */
+    readonly draft?: CreateDraft | undefined;
+    /**
+     * Where a canvas drop landed, or `null`. Read for its NULLNESS alone.
+     *
+     * THE PANEL SUPPRESSES ITS KIND LIST WHILE A DROP IS LIVE, which is the
+     * invariant that keeps the two choosers mutually exclusive. A drag that ends
+     * on the canvas opens a chooser AT THE DROP POINT; a panel list drawn at the
+     * same moment would be a second copy of the same step, one under the
+     * reader's pointer and one in the column beside it, both writing to the one
+     * draft. The shell held that rule alone while it drew both, and it cannot
+     * hold it any more now that one of them is package markup.
+     *
+     * The host's own value is forwarded rather than a boolean derived from it:
+     * a `dropInFlight: boolean` would be a second spelling of a fact the shell
+     * already holds, free to disagree with it on the render where it matters.
+     */
+    readonly drop?: Point | null | undefined;
+    /**
+     * The edits the store refused, so the panel can say so where the reader made
+     * them. See {@link WorkspaceRefusal}.
+     *
+     * IN THE ORDER THE STORE RECORDED THEM, and that is part of the contract
+     * rather than an accident of how a caller happened to build it. One row
+     * states one reason, so two refusals naming one edge collapse to the LAST —
+     * the one the reader just caused, rather than the one they have read and
+     * moved past. A caller assembling this from two passes and concatenating
+     * them loses that chronology at the join; `mountWorkspace` walks
+     * `snapshot.writes` once for exactly this reason.
+     *
+     * ABSENT MEANS "NOTHING REFUSED", which is unlike {@link WorkspaceOptions.audit}
+     * and is safe for the reason that one is not: a refusal is a fact the store
+     * produces, so a host with no refusals to report and a host that never asked
+     * are in the same position — there is nothing to draw either way. An audit
+     * count is a NUMBER, and inventing a zero for one nobody computed is the
+     * distinction that option exists to keep.
+     */
+    readonly refusals?: readonly WorkspaceRefusal[] | undefined;
+    /**
+     * The failed and conflicted writes the reader can still act on.
+     *
+     * OPTIONAL, on the same reasoning as {@link WorkspaceOptions.refusals}: an
+     * unsettled write is a fact the store produces, so "none" and "never asked"
+     * leave the panel with the same nothing to draw.
+     */
+    readonly recoveries?: readonly WorkspaceRecovery[] | undefined;
+    /**
+     * Which conflict has its difference open, if any.
+     *
+     * ONE AT A TIME, because the region is inside a panel rather than a dialog.
+     * The shell holds it for the reason `auditFiltered` is held: the card
+     * publishes a toggle, so something has to carry its state or every render
+     * answers "closed" and the control cannot complete what it advertises.
+     */
+    readonly diffOpen?: MutationId | null | undefined;
 }
 export interface WorkspaceView {
     readonly selection: WorkspaceSelection;

package/dist/workspace/render.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../src/workspace/render.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAEH,OAAO,EAIL,KAAK,KAAK,EACV,KAAK,cAAc,EAUpB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD,OAAO,KAAK,EAAE,UAAU,EAAiB,MAAM,sBAAsB,CAAC;AAGtE,OAAO,EAEL,KAAK,YAAY,EAKlB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,KAAK,UAAU,EAAuB,MAAM,sBAAsB,CAAC;AAI5E,OAAO,EAA8B,KAAK,aAAa,EAAiB,MAAM,gBAAgB,CAAC;AAC/F,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,iBAAiB,EAAc,MAAM,WAAW,CAAC;AAChF,OAAO,EACL,KAAK,kBAAkB,EAIxB,MAAM,gBAAgB,CAAC;AAGxB,iFAAiF;AACjF,eAAO,MAAM,KAAK,oDAAoE,CAAC;AAEvF,MAAM,MAAM,IAAI,GAAG,CAAC,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC;AAE1C,MAAM,WAAW,cAAc;IAC7B,uDAAuD;IACvD,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC;;;;;;;;OAQG;IACH,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,oCAAoC;IACpC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAED,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAC/B,QAAQ,CAAC,SAAS,CAAC,EAAE,kBAAkB,GAAG,SAAS,CAAC;IACpD,qEAAqE;IACrE,QAAQ,CAAC,KAAK,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC;IACxC,uEAAuE;IACvE,QAAQ,CAAC,IAAI,CAAC,EAAE,iBAAiB,GAAG,SAAS,CAAC;IAC9C;;;;;;OAMG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC;IACxC;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC7C,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;IACnC,mEAAmE;IACnE,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5C;;;;OAIG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,aAAa,EAAE,GAAG,SAAS,CAAC;CAC3D;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,SAAS,EAAE,kBAAkB,CAAC;IACvC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC;IAClC,oFAAoF;IACpF,QAAQ,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI,CAAC;IACpC;;;;;;OAMG;IACH,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;CACjC;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,yDAAyD;IACzD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,6DAA6D;IAC7D,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CACzC;AAyRD,0EAA0E;AAC1E,wBAAgB,eAAe,CAC7B,KAAK,EAAE,cAAc,EACrB,OAAO,EAAE,gBAAgB,GACxB,eAAe,CAsKjB"}
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../src/workspace/render.ts"],"names":[],"mappings":"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"}