@issuegraph/editor 0.1.0

package/dist/scale/styles.js

@@ -0,0 +1,105 @@
+/**
+ * The ladder chrome's structural stylesheet.
+ *
+ * Same contract as the viewer's, and for the same reason: it carries layout,
+ * weight and state, never a value. Every colour, length and font here is a
+ * `var(--ig-…)` the host's theme resolves, so a second theme keeps working on
+ * the surfaces layer 2 adds rather than only on layer 1's. `styles.test.ts`
+ * scans these bytes for a literal colour or a fixed length and for a token the
+ * theme does not define, so the rule is enforced rather than remembered.
+ *
+ * IT ADDS SELECTORS RATHER THAN REDEFINING THEM. The refusal, its capsules and
+ * their counts already have a look — this file styles only what layer 2
+ * introduces: the ladder container, the routes, the search box, the isolated
+ * chip and the list it opens.
+ *
+ * Shipped as a string for the same reason the viewer's is: an entry that
+ * imports CSS cannot be loaded by a bare Node runtime, and a string needs no
+ * bundler.
+ */
+export const scaleLadderStylesheet = `
+.ig-ladder {
+  display: flex;
+  flex-direction: column;
+  gap: var(--ig-space);
+  font-family: var(--ig-font-ui);
+  font-size: var(--ig-font-size);
+  line-height: var(--ig-line-height);
+  color: var(--ig-text-body);
+}
+
+.ig-ladder-routes {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: var(--ig-space-tight);
+  color: var(--ig-text-muted);
+  font-size: var(--ig-font-size-small);
+}
+
+.ig-ladder-search {
+  display: flex;
+  flex-direction: column;
+  gap: var(--ig-space-tight);
+}
+
+.ig-ladder-search input {
+  background: var(--ig-surface);
+  color: var(--ig-text);
+  border: var(--ig-stroke) solid var(--ig-line);
+  border-radius: var(--ig-radius);
+  padding: var(--ig-space-tight);
+  font-family: var(--ig-font-ui);
+  font-size: var(--ig-font-size);
+}
+
+.ig-ladder-search input:focus-visible {
+  outline: var(--ig-focus-ring) solid var(--ig-focus);
+  outline-offset: var(--ig-space-tight);
+}
+
+.ig-ladder-match {
+  display: flex;
+  gap: var(--ig-space-tight);
+  align-items: baseline;
+}
+
+.ig-chip {
+  align-self: flex-start;
+  background: var(--ig-surface-2);
+  color: var(--ig-text-body);
+  border: var(--ig-stroke) solid var(--ig-line);
+  border-radius: var(--ig-radius);
+  padding: var(--ig-space-tight) var(--ig-space);
+  font-family: var(--ig-font-ui);
+  font-size: var(--ig-font-size-small);
+  cursor: pointer;
+}
+
+.ig-chip:focus-visible {
+  outline: var(--ig-focus-ring) solid var(--ig-focus);
+  outline-offset: var(--ig-space-tight);
+}
+
+.ig-chip[aria-expanded='true'] {
+  border-color: var(--ig-accent);
+  color: var(--ig-text);
+}
+
+.ig-isolated-list {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: var(--ig-space-tight);
+}
+
+.ig-isolated-list .ig-id {
+  font-family: var(--ig-font-mono);
+  color: var(--ig-text-muted);
+}
+`;
+//# sourceMappingURL=styles.js.map

package/dist/scale/styles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles.js","sourceRoot":"","sources":["../../src/scale/styles.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,MAAM,CAAC,MAAM,qBAAqB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoFpC,CAAC"}

package/dist/workspace/inspector.d.ts

@@ -0,0 +1,117 @@
+/**
+ * The inspector: detail, the "why", relationships, and the edit affordances
+ * that hang off them.
+ *
+ * ## It is a projection of the selection, and holds no state of its own
+ *
+ * §17b makes `selected` the one edge state that also filters the inspector, so
+ * this zone is a pure function of the document and that single value. It keeps
+ * no "currently inspecting" of its own — a second copy would be free to
+ * disagree with the rail and the canvas about what is selected, which is the
+ * whole reason the workspace owns exactly one selection.
+ *
+ * ## An edge selection FILTERS; it does not open a different panel
+ *
+ * The distinction matters and it is easy to lose. With an edge selected the
+ * inspector shows the same relationship list, narrowed to that one edge —
+ * rather than a separate edge inspector. So the reader's frame of reference
+ * never jumps.
+ *
+ * CLEARING RETURNS TO NOTHING SELECTED, NOT TO A WIDER LIST — and an earlier
+ * revision of this comment said the opposite, which is how a control came to be
+ * worded "show every relationship" while it emptied the panel. §17b makes the
+ * inspector a projection of the SELECTION, and `none` is a selection with no
+ * subject, so there is no list for it to widen to.
+ *
+ * The alternative was considered and not taken: `none` could list every
+ * relationship in the document, which would make the three states a clean
+ * narrowing — all, then one issue's, then one edge's — and make "show every
+ * relationship" literally true. It also invents a fourth thing for the panel to
+ * be, on a zone whose whole contract is that it shows what is selected. The
+ * cheaper repair was to stop the prose promising a behaviour the design does
+ * not have.
+ *
+ * ## Edge identity comes from `@issuegraph/core`
+ *
+ * A `ViewerEdge` carries no id — layer 1 has no need of one — but the picker,
+ * the overlays and the store all name edges by the identity `edgeIdentity`
+ * derives from content. Recomputing it here is composing the foundation both
+ * layers already sit on, which is the same crossing `picker/view.ts` declared
+ * and for the same reason: a local second spelling of an identity is how a host
+ * comes to hold two ids for one edge.
+ */
+import type { EdgeField } from '@issuegraph/core';
+import type { ViewerDocument, ViewerHold, ViewerIssue } from '@issuegraph/viewer';
+import type { WorkspaceSelection } from './selection.ts';
+/** One relationship, as the inspector lists it. */
+export interface InspectorRelationship {
+    /** The identity `@issuegraph/core` derives — what a retype or delete names. */
+    readonly edgeId: string;
+    readonly field: EdgeField;
+    readonly from: string;
+    readonly to: string;
+    /**
+     * Which end the subject is on — `null` when there is no direction to state.
+     *
+     * A DIRECTION RELATIVE TO THE SUBJECT, not a sentence: "blocked-by, outgoing"
+     * is a fact, and the English for it is the host's to write. The package
+     * refuses to construct one, exactly as the picker does.
+     *
+     * NULL FOR A SYMMETRIC FIELD, and that is a fact about the FORMAT rather
+     * than a rendering choice. `serialize-with` and `together-with` state the
+     * same relationship whichever way round their endpoints are stored —
+     * `edgeIdentity` normalizes them for exactly that reason — so a direction
+     * read off the stored order is one that does not exist, and a host wording
+     * it would describe the relationship wrongly. `picker/view.ts` already
+     * refuses a direction for those two kinds; this now agrees with it instead
+     * of contradicting it from the next zone over.
+     *
+     * Also `null` when the subject is not an issue: an edge selection has no
+     * "my end" to be relative to.
+     */
+    readonly direction: 'outgoing' | 'incoming' | null;
+}
+/** What the inspector knows about the selected issue's position. */
+export interface InspectorPosition {
+    /** 1-based, or `null` for a held slot — the viewer's own convention. */
+    readonly rank: number | null;
+    readonly ready: boolean;
+    readonly holds: readonly ViewerHold[];
+}
+export interface InspectorView {
+    /**
+     * What the selection resolved to.
+     *
+     * `none` covers both "nothing selected" and "the selection no longer
+     * resolves". They are deliberately one state rather than two: a selection
+     * that named a row a write has since removed is not an error a reader can
+     * act on, and rendering last frame's answer for it is the stale-detail bug
+     * that keeping no document on the selection exists to prevent.
+     */
+    readonly subject: {
+        readonly kind: 'none';
+    } | {
+        readonly kind: 'issue';
+        readonly issue: ViewerIssue;
+        readonly position: InspectorPosition | null;
+    } | {
+        readonly kind: 'edge';
+        readonly relationship: InspectorRelationship;
+    };
+    /**
+     * The relationships on show: every one touching the selected issue, the one
+     * selected edge, or none.
+     */
+    readonly relationships: readonly InspectorRelationship[];
+    /** Whether an edge selection is narrowing the list. Drives the clear control. */
+    readonly filtered: boolean;
+}
+/**
+ * Project a document and a selection onto the inspector.
+ *
+ * Pure and total: an unresolvable selection returns the empty view rather than
+ * throwing, because a document changing under a selection is ordinary — a write
+ * lands, the order recomputes — and is not a condition a reader can fix.
+ */
+export declare function inspectorView(raw: ViewerDocument, selection: WorkspaceSelection): InspectorView;
+//# sourceMappingURL=inspector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inspector.d.ts","sourceRoot":"","sources":["../../src/workspace/inspector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,WAAW,EAAc,MAAM,oBAAoB,CAAC;AAG9F,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAEzD,mDAAmD;AACnD,MAAM,WAAW,qBAAqB;IACpC,+EAA+E;IAC/E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB;;;;;;;;;;;;;;;;;;OAkBG;IACH,QAAQ,CAAC,SAAS,EAAE,UAAU,GAAG,UAAU,GAAG,IAAI,CAAC;CACpD;AAED,oEAAoE;AACpE,MAAM,WAAW,iBAAiB;IAChC,wEAAwE;IACxE,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,CAAC;CACvC;AAED,MAAM,WAAW,aAAa;IAC5B;;;;;;;;OAQG;IACH,QAAQ,CAAC,OAAO,EACZ;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GACzB;QAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;QAAC,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAAA;KAAE,GACpG;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,YAAY,EAAE,qBAAqB,CAAA;KAAE,CAAC;IAC5E;;;OAGG;IACH,QAAQ,CAAC,aAAa,EAAE,SAAS,qBAAqB,EAAE,CAAC;IACzD,iFAAiF;IACjF,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC5B;AAkCD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,cAAc,EACnB,SAAS,EAAE,kBAAkB,GAC5B,aAAa,CAmEf"}

package/dist/workspace/inspector.js

@@ -0,0 +1,140 @@
+/**
+ * The inspector: detail, the "why", relationships, and the edit affordances
+ * that hang off them.
+ *
+ * ## It is a projection of the selection, and holds no state of its own
+ *
+ * §17b makes `selected` the one edge state that also filters the inspector, so
+ * this zone is a pure function of the document and that single value. It keeps
+ * no "currently inspecting" of its own — a second copy would be free to
+ * disagree with the rail and the canvas about what is selected, which is the
+ * whole reason the workspace owns exactly one selection.
+ *
+ * ## An edge selection FILTERS; it does not open a different panel
+ *
+ * The distinction matters and it is easy to lose. With an edge selected the
+ * inspector shows the same relationship list, narrowed to that one edge —
+ * rather than a separate edge inspector. So the reader's frame of reference
+ * never jumps.
+ *
+ * CLEARING RETURNS TO NOTHING SELECTED, NOT TO A WIDER LIST — and an earlier
+ * revision of this comment said the opposite, which is how a control came to be
+ * worded "show every relationship" while it emptied the panel. §17b makes the
+ * inspector a projection of the SELECTION, and `none` is a selection with no
+ * subject, so there is no list for it to widen to.
+ *
+ * The alternative was considered and not taken: `none` could list every
+ * relationship in the document, which would make the three states a clean
+ * narrowing — all, then one issue's, then one edge's — and make "show every
+ * relationship" literally true. It also invents a fourth thing for the panel to
+ * be, on a zone whose whole contract is that it shows what is selected. The
+ * cheaper repair was to stop the prose promising a behaviour the design does
+ * not have.
+ *
+ * ## Edge identity comes from `@issuegraph/core`
+ *
+ * A `ViewerEdge` carries no id — layer 1 has no need of one — but the picker,
+ * the overlays and the store all name edges by the identity `edgeIdentity`
+ * derives from content. Recomputing it here is composing the foundation both
+ * layers already sit on, which is the same crossing `picker/view.ts` declared
+ * and for the same reason: a local second spelling of an identity is how a host
+ * comes to hold two ids for one edge.
+ */
+import { edgeIdentity, isSymmetricEdgeField } from '@issuegraph/core';
+import { normalizeDocument } from '@issuegraph/viewer';
+const EMPTY = {
+    subject: { kind: 'none' },
+    relationships: [],
+    filtered: false,
+};
+/** Every relationship in the document, carrying the identity edits name. */
+function relationshipsOf(document, subject) {
+    return document.edges.map((edge) => ({
+        edgeId: edgeIdentity(edge.field, edge.from, edge.to),
+        field: edge.field,
+        from: edge.from,
+        to: edge.to,
+        direction: subject === null ||
+            isSymmetricEdgeField(edge.field) ||
+            (edge.from !== subject && edge.to !== subject)
+            ? null
+            : edge.from === subject
+                ? 'outgoing'
+                : 'incoming',
+    }));
+}
+/** The slot carrying a key, if the order places it. */
+function slotFor(document, key) {
+    return document.order.slots.find((slot) => slot.members.includes(key));
+}
+/**
+ * Project a document and a selection onto the inspector.
+ *
+ * Pure and total: an unresolvable selection returns the empty view rather than
+ * throwing, because a document changing under a selection is ordinary — a write
+ * lands, the order recomputes — and is not a condition a reader can fix.
+ */
+export function inspectorView(raw, selection) {
+    if (selection.kind === 'none')
+        return EMPTY;
+    // IT NORMALIZES ITS OWN INPUT, so the list can never disagree with what the
+    // other zones drew. Reading the raw edges published relationships layer 1 had
+    // already dropped — a dangling edge, a repeated one, a self-edge — each with
+    // a live `select-edge` command on it, so the inspector offered the reader an
+    // edge that exists on no other surface.
+    //
+    // Inside rather than at the call site, because this is exported: a host
+    // calling it directly gets the same answer the workspace does. Idempotent, so
+    // the workspace normalizing first costs a pass and changes nothing.
+    const document = normalizeDocument(raw).document;
+    if (selection.kind === 'issue') {
+        // CANONICALIZED TO THE SLOT LEAD, because a together unit is ONE row and
+        // layer 1 has already decided which member speaks for it. `ViewerSlot.lead`
+        // is documented as "the detail surface's subject", and both projections run
+        // their options through `atStations` before drawing — so a selection naming
+        // a PARTNER marked the lead current in the rail and on the canvas while this
+        // panel showed the partner's title and relationships. Two zones naming
+        // different issues for one selection, which is the exact thing holding a
+        // single selection value was supposed to make impossible.
+        //
+        // Falls back to the key itself when the order does not place it: an
+        // excluded or unplaced issue is its own subject, and there is no lead to
+        // defer to.
+        const placement = slotFor(document, selection.key);
+        const subject = placement?.lead ?? selection.key;
+        const issue = document.issues.find((candidate) => candidate.key === subject);
+        if (issue === undefined)
+            return EMPTY;
+        const slot = placement;
+        return {
+            subject: {
+                kind: 'issue',
+                issue,
+                // NULL RATHER THAN A FABRICATED POSITION. An issue the order excludes —
+                // a duplicate — genuinely has no position, and inventing `rank: null,
+                // ready: false` for it would read as a hold, which is a different fact
+                // with a different remedy.
+                position: slot === undefined
+                    ? null
+                    : { rank: slot.rank, ready: slot.ready, holds: slot.holds },
+            },
+            // FILTERED ON MEMBERSHIP, NOT ON DIRECTION. Those were the same question
+            // only while every edge touching the subject had one — and the moment a
+            // symmetric field correctly reported `null`, a `together-with` or
+            // `serialize-with` on the selected issue disappeared from the panel
+            // entirely. "Does this edge touch my subject" and "which end is my
+            // subject on" are different questions, and only the first belongs here.
+            relationships: relationshipsOf(document, subject).filter((relationship) => relationship.from === subject || relationship.to === subject),
+            filtered: false,
+        };
+    }
+    const relationship = relationshipsOf(document, null).find((candidate) => candidate.edgeId === selection.edgeId);
+    if (relationship === undefined)
+        return EMPTY;
+    return {
+        subject: { kind: 'edge', relationship },
+        relationships: [relationship],
+        filtered: true,
+    };
+}
+//# sourceMappingURL=inspector.js.map

package/dist/workspace/inspector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspector.js","sourceRoot":"","sources":["../../src/workspace/inspector.ts"],"names":[],"mappings":"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"}

package/dist/workspace/rail.d.ts

@@ -0,0 +1,122 @@
+/**
+ * The order rail: always present, always complete, and virtualised.
+ *
+ * ## The asymmetry with the canvas is the design, not an inconsistency
+ *
+ * §17f gives the two centre zones opposite obligations. The canvas answers
+ * "what surrounds this issue" and REFUSES above its budget — that is #10343's
+ * scale ladder, and it is correct. The rail answers "what gets worked next" for
+ * the whole backlog and must NEVER refuse. Assembling them must not average the
+ * two: a rail that paginates has stopped answering its question, and a canvas
+ * that tries to keep up with the rail has stopped honouring its budget.
+ *
+ * So virtualisation here is a requirement rather than an optimisation, and it
+ * is the resolution of what reads at first like a contradiction — "complete"
+ * and "windowed" at once.
+ *
+ * **The MODEL is complete; the WINDOW is bounded.** Every slot the host handed
+ * over is held, and {@link RailWindow.addressOf} answers for every rank in the
+ * order whether or not it is drawn. What is bounded is only how many rows are
+ * rendered at a time. Nothing is dropped, nothing is refused, and a host that
+ * scrolls asks for a different window over the same complete model.
+ *
+ * That is what "every rank is addressable" means, and it is the property the
+ * acceptance suite drives at 312 rows.
+ *
+ * ## `addressOf` is a closure over a private index
+ *
+ * The same shape — and the same reasoning — as `AuditOverlay.rowFor`. Handing
+ * out the index itself would let a JavaScript consumer mutate it, after which
+ * the lookups and `total` would disagree about what the order contains, which
+ * is the inconsistency this value exists to prevent. A closure cannot be
+ * reached at all, and still answers in constant time.
+ *
+ * ## What gets windowed
+ *
+ * Slots are sliced, and the issues and edges are cut down to exactly what the
+ * drawn rows need — a drawn slot's members, an exclusion's key, and the
+ * endpoints of any edge a drawn row owes a badge for.
+ *
+ * KEEPING THE WHOLE ISSUE LIST WAS THE OBVIOUS THING AND IT WAS WRONG. See the
+ * note at the filter itself for what it cost: the linear projection renders a
+ * count of the keys that appear in no slot and on no edge, so every edgeless
+ * issue outside the window was reported to the reader as isolated — the rail
+ * describing the reader's scroll position as though it were the document.
+ *
+ * `together-with` keeps its own rule, and it is layer 1's rather than a choice
+ * made here: that edge draws as an ENCLOSURE around one slot's members, so the
+ * viewer drops — and reports — any whose members no longer share a drawn slot.
+ * Those edges are left out of the windowed document and counted on
+ * {@link RailWindow.undrawn} instead, so the fact is reported as a property of
+ * the WINDOW rather than leaking out as a document defect.
+ */
+import type { ViewerDocument, ViewerSlot } from '@issuegraph/viewer';
+/**
+ * How many rows a window holds when the host does not say.
+ *
+ * A round number rather than a measured one: this package has no mount and
+ * therefore no viewport to measure, so any default here is a guess. It is
+ * published so a host can see what it is overriding, and generous enough that
+ * a first paint fills an ordinary screen.
+ */
+export declare const RAIL_WINDOW = 50;
+export interface RailWindowOptions {
+    /**
+     * The first row to draw, as a 0-BASED offset into the order's slots.
+     *
+     * An offset, deliberately, and not a rank: a held slot has `rank === null`,
+     * so ranks are not a coordinate you can slice on. Out-of-range values are
+     * clamped rather than refused — a host that scrolls past the end gets the
+     * last window, which is what a scroll container does anyway.
+     */
+    readonly start?: number | undefined;
+    /** How many rows to draw. Defaults to {@link RAIL_WINDOW}. */
+    readonly count?: number | undefined;
+}
+export interface RailWindow {
+    /** Every slot in the order, drawn or not. The completeness claim, as a number. */
+    readonly total: number;
+    /** The 0-based offset of the first drawn row, after clamping. */
+    readonly start: number;
+    /** How many rows are drawn. Fewer than asked for at the end of the order. */
+    readonly count: number;
+    /** Slots before the window. A host sizes its leading spacer from this. */
+    readonly before: number;
+    /** Slots after the window. A host sizes its trailing spacer from this. */
+    readonly after: number;
+    /** The drawn slots, in order. */
+    readonly rows: readonly ViewerSlot[];
+    /** The document to hand the viewer: the windowed slots, and what they need. */
+    readonly document: ViewerDocument;
+    /**
+     * `together-with` edges left out because their unit is outside the window.
+     *
+     * Reported rather than silent: it is the one thing windowing costs, and a
+     * host drawing a connector count of its own needs to know the window is not
+     * the whole story.
+     */
+    readonly undrawn: number;
+    /**
+     * The slot at a rank — ANY rank in the order, drawn or not.
+     *
+     * This is the completeness property, and it is why the rail can be windowed
+     * without ceasing to answer its question: a reader asking "what is at 287?"
+     * gets an answer from a rail showing rows 1–50.
+     *
+     * Ranks are 1-BASED, matching what the rail renders and what a reader sees.
+     * A held slot has no rank at all and is unreachable this way by construction
+     * — it has no position in the sequence, which is precisely what `rank: null`
+     * says.
+     */
+    readonly addressOf: (rank: number) => ViewerSlot | undefined;
+    /** The 0-based offset of a slot's lead key, for a host scrolling to it. */
+    readonly offsetOf: (key: string) => number | undefined;
+}
+/**
+ * Window an order without narrowing it.
+ *
+ * Pure, and total over any document: there is no input that makes this throw or
+ * refuse, because the rail is the zone that is not allowed to.
+ */
+export declare function railWindow(raw: ViewerDocument, options?: RailWindowOptions): RailWindow;
+//# sourceMappingURL=rail.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rail.d.ts","sourceRoot":"","sources":["../../src/workspace/rail.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAGrE;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,KAAK,CAAC;AAE9B,MAAM,WAAW,iBAAiB;IAChC;;;;;;;OAOG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,8DAA8D;IAC9D,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACrC;AAED,MAAM,WAAW,UAAU;IACzB,kFAAkF;IAClF,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,iEAAiE;IACjE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,6EAA6E;IAC7E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,0EAA0E;IAC1E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,0EAA0E;IAC1E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,iCAAiC;IACjC,QAAQ,CAAC,IAAI,EAAE,SAAS,UAAU,EAAE,CAAC;IACrC,+EAA+E;IAC/E,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,UAAU,GAAG,SAAS,CAAC;IAC7D,2EAA2E;IAC3E,QAAQ,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;CACxD;AA4BD;;;;;GAKG;AACH,wBAAgB,UAAU,CACxB,GAAG,EAAE,cAAc,EACnB,OAAO,GAAE,iBAAsB,GAC9B,UAAU,CAgIZ"}