@elaraai/e3-ui 1.0.86 → 1.0.88

package/dist/src/flowchart/types.d.ts

@@ -0,0 +1,393 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+import { ArrayType, DateTimeType, DictType, FloatType, IntegerType, NullType, OptionType, StringType, StructType, VariantType } from "@elaraai/east";
+/**
+ * Link kind — the transition's provenance class.
+ *
+ * @remarks
+ * `planned` renders solid; `observed` renders dashed (5/4). A link whose
+ * `from` / `to` reference has no state row is *unresolved* — that is a
+ * derived render class (dashed 4/4 in the negative tone against a ghost
+ * "No state row" node), never an authored kind.
+ *
+ * @property planned - A designed / expected transition (solid stroke)
+ * @property observed - A transition mined from evidence (dashed stroke)
+ */
+export declare const FlowchartLinkKindType: VariantType<{
+    /** A designed / expected transition (solid stroke) */
+    readonly planned: NullType;
+    /** A transition mined from evidence (dashed stroke) */
+    readonly observed: NullType;
+}>;
+/**
+ * Type representing flowchart link kinds.
+ */
+export type FlowchartLinkKindType = typeof FlowchartLinkKindType;
+/**
+ * Canvas orientation — which axis the lane bands run along.
+ *
+ * @remarks
+ * Orientation is VIEW state, not slice state: the eyebrow's orientation
+ * segment toggles it and it never appears as a filter chip. `LR` lays
+ * lanes left→right (links flow rightward); `TD` swaps the axes.
+ *
+ * @property LR - Lanes run left → right
+ * @property TD - Lanes run top → down
+ */
+export declare const FlowchartOrientationType: VariantType<{
+    /** Lanes run left → right */
+    readonly LR: NullType;
+    /** Lanes run top → down */
+    readonly TD: NullType;
+}>;
+/**
+ * Type representing flowchart orientations.
+ */
+export type FlowchartOrientationType = typeof FlowchartOrientationType;
+/**
+ * Imported evidence carried by a link — never hand-authored.
+ *
+ * @remarks
+ * Evidence drives derived marks only: stroke weight scales with `volume`
+ * (log scale 1.6 / 2 / 2.5 px, floor 1.4), `volume` + `unit` print as the
+ * paper-filled badge on the longest straight run, and the inspector shows
+ * all four, read only, under the transition's fields (#1250).
+ *
+ * @property volume - Total measured volume behind the arrow
+ * @property count - Event count behind the arrow (e.g. cage moves)
+ * @property measuredAt - When the evidence was measured
+ * @property unit - Volume unit suffix for badges ("parcels")
+ */
+export declare const FlowchartEvidenceType: StructType<{
+    /** Total measured volume behind the arrow */
+    readonly volume: OptionType<FloatType>;
+    /** Event count behind the arrow (e.g. cage moves) */
+    readonly count: OptionType<IntegerType>;
+    /** When the evidence was measured */
+    readonly measuredAt: OptionType<DateTimeType>;
+    /** Volume unit suffix for badges ("parcels") */
+    readonly unit: OptionType<StringType>;
+}>;
+/**
+ * Type representing link evidence.
+ */
+export type FlowchartEvidenceType = typeof FlowchartEvidenceType;
+/**
+ * One state — a node in the flowchart.
+ *
+ * @remarks
+ * The short mono `key` is the node identity everywhere (selection events,
+ * link `from` / `to` refs, trigger queues). A state with `members` set is
+ * a STATE CLASS — one node standing for N interchangeable members (the
+ * `×N` badge). In-place transitions (`from == to` links) collapse to the
+ * `↻ n` badge on the node and never route through handles.
+ *
+ * @property key - Short mono code — the node identity ("IND")
+ * @property label - Display label under the code
+ * @property lane - The lane (ordered phase) this state belongs to
+ * @property members - State-class member count → the ×N badge
+ * @property notes - Free-text notes, shown and edited in the inspector
+ */
+export declare const FlowchartStateType: StructType<{
+    /** Short mono code — the node identity ("IND") */
+    readonly key: StringType;
+    /** Display label under the code */
+    readonly label: OptionType<StringType>;
+    /** The lane (ordered phase) this state belongs to */
+    readonly lane: StringType;
+    /** State-class member count → the ×N badge */
+    readonly members: OptionType<IntegerType>;
+    /** Free-text notes, shown and edited in the inspector */
+    readonly notes: OptionType<StringType>;
+}>;
+/**
+ * Type representing flowchart states.
+ */
+export type FlowchartStateType = typeof FlowchartStateType;
+/**
+ * One link — a state transition drawn as an H/V-routed arrow.
+ *
+ * @remarks
+ * `from` / `to` are state keys; a reference with no state row renders the
+ * neg-dashed ghost "No state row" node (derived, counted in the footer).
+ * At most one `trigger` per link — the lettered decision diamond anchored
+ * to the midpoint of the longest straight run.
+ *
+ * @property key - Stable identity (selection / delete events); default derived from endpoints
+ * @property from - Source state key
+ * @property to - Target state key
+ * @property kind - planned (default) | observed
+ * @property trigger - 0..1 decision trigger key → diamond
+ * @property evidence - Imported evidence (weight, badges, provenance)
+ */
+export declare const FlowchartLinkType: StructType<{
+    /** Stable identity (selection / delete events); default derived from endpoints */
+    readonly key: OptionType<StringType>;
+    /** Source state key */
+    readonly from: StringType;
+    /** Target state key */
+    readonly to: StringType;
+    /** planned (default) | observed */
+    readonly kind: OptionType<VariantType<{
+        /** A designed / expected transition (solid stroke) */
+        readonly planned: NullType;
+        /** A transition mined from evidence (dashed stroke) */
+        readonly observed: NullType;
+    }>>;
+    /** 0..1 decision trigger key → diamond */
+    readonly trigger: OptionType<StringType>;
+    /** Imported evidence (weight, badges, provenance) */
+    readonly evidence: OptionType<StructType<{
+        /** Total measured volume behind the arrow */
+        readonly volume: OptionType<FloatType>;
+        /** Event count behind the arrow (e.g. cage moves) */
+        readonly count: OptionType<IntegerType>;
+        /** When the evidence was measured */
+        readonly measuredAt: OptionType<DateTimeType>;
+        /** Volume unit suffix for badges ("parcels") */
+        readonly unit: OptionType<StringType>;
+    }>>;
+}>;
+/**
+ * Type representing flowchart links.
+ */
+export type FlowchartLinkType = typeof FlowchartLinkType;
+/**
+ * One lane — an ordered phase band.
+ *
+ * @remarks
+ * Lane order is array order; every state names its lane by `key`. The
+ * dashed `+ LANE` affordance renders at the tail of the band row.
+ *
+ * @property key - Lane identity referenced by states
+ * @property label - Band header label (defaults to the key, uppercased)
+ */
+export declare const FlowchartLaneType: StructType<{
+    /** Lane identity referenced by states */
+    readonly key: StringType;
+    /** Band header label (defaults to the key, uppercased) */
+    readonly label: OptionType<StringType>;
+}>;
+/**
+ * Type representing flowchart lanes.
+ */
+export type FlowchartLaneType = typeof FlowchartLaneType;
+/**
+ * One decision trigger — a governed decision seam referenced by links.
+ *
+ * @remarks
+ * Triggers render as diamonds (max one per link) carrying a letter per
+ * TYPE, not per instance. Clicking a diamond highlights every link it
+ * governs (plus queue and outcome nodes).
+ *
+ * @property key - Trigger identity referenced by links
+ * @property label - Decision name ("route")
+ * @property letter - Diamond letter (default: first letter of the label)
+ * @property owner - Owning role / system ("sort-planner")
+ * @property queue - State keys queued at the decision
+ * @property outcomes - Outcome summary line ("CH* (×14 chutes)")
+ */
+export declare const FlowchartTriggerType: StructType<{
+    /** Trigger identity referenced by links */
+    readonly key: StringType;
+    /** Decision name ("route") */
+    readonly label: StringType;
+    /** Diamond letter (default: first letter of the label) */
+    readonly letter: OptionType<StringType>;
+    /** Owning role / system ("sort-planner") */
+    readonly owner: OptionType<StringType>;
+    /** State keys queued at the decision */
+    readonly queue: OptionType<ArrayType<StringType>>;
+    /** Outcome summary line ("CH* (×14 chutes)") */
+    readonly outcomes: OptionType<StringType>;
+}>;
+/**
+ * Type representing flowchart triggers.
+ */
+export type FlowchartTriggerType = typeof FlowchartTriggerType;
+/**
+ * One flow — a whole flowchart: its lanes, its states, the transitions
+ * between them and the decisions that govern them (#1244, `Flowchart Builder
+ * Spec.md` §5.1).
+ *
+ * @remarks
+ * A record of flows holds one per name ({@link FlowchartFlowsType}), and a
+ * lone flow is a record of one entry, or the host's `data`. `Flowchart.value`
+ * writes one from a literal, and `Flowchart.over` builds one from an app's
+ * own tables. A record's entries are flows, so it is a stored form.
+ *
+ * @property description - One sentence about the flow: the line its card in the Flows tab shows
+ * @property lanes - Its lanes, in band order
+ * @property states - Its states, each in one of its lanes
+ * @property links - Its transitions; one naming a state the flow does not have draws as the unresolved ghost
+ * @property triggers - Its decisions, each named by the transitions it governs
+ */
+export declare const FlowchartFlowType: StructType<{
+    /** One sentence about the flow: the line its card in the Flows tab shows */
+    readonly description: OptionType<StringType>;
+    /** Its lanes, in band order */
+    readonly lanes: ArrayType<StructType<{
+        /** Lane identity referenced by states */
+        readonly key: StringType;
+        /** Band header label (defaults to the key, uppercased) */
+        readonly label: OptionType<StringType>;
+    }>>;
+    /** Its states, each in one of its lanes */
+    readonly states: ArrayType<StructType<{
+        /** Short mono code — the node identity ("IND") */
+        readonly key: StringType;
+        /** Display label under the code */
+        readonly label: OptionType<StringType>;
+        /** The lane (ordered phase) this state belongs to */
+        readonly lane: StringType;
+        /** State-class member count → the ×N badge */
+        readonly members: OptionType<IntegerType>;
+        /** Free-text notes, shown and edited in the inspector */
+        readonly notes: OptionType<StringType>;
+    }>>;
+    /** Its transitions; one naming a state the flow does not have draws as the unresolved ghost */
+    readonly links: ArrayType<StructType<{
+        /** Stable identity (selection / delete events); default derived from endpoints */
+        readonly key: OptionType<StringType>;
+        /** Source state key */
+        readonly from: StringType;
+        /** Target state key */
+        readonly to: StringType;
+        /** planned (default) | observed */
+        readonly kind: OptionType<VariantType<{
+            /** A designed / expected transition (solid stroke) */
+            readonly planned: NullType;
+            /** A transition mined from evidence (dashed stroke) */
+            readonly observed: NullType;
+        }>>;
+        /** 0..1 decision trigger key → diamond */
+        readonly trigger: OptionType<StringType>;
+        /** Imported evidence (weight, badges, provenance) */
+        readonly evidence: OptionType<StructType<{
+            /** Total measured volume behind the arrow */
+            readonly volume: OptionType<FloatType>;
+            /** Event count behind the arrow (e.g. cage moves) */
+            readonly count: OptionType<IntegerType>;
+            /** When the evidence was measured */
+            readonly measuredAt: OptionType<DateTimeType>;
+            /** Volume unit suffix for badges ("parcels") */
+            readonly unit: OptionType<StringType>;
+        }>>;
+    }>>;
+    /** Its decisions, each named by the transitions it governs */
+    readonly triggers: ArrayType<StructType<{
+        /** Trigger identity referenced by links */
+        readonly key: StringType;
+        /** Decision name ("route") */
+        readonly label: StringType;
+        /** Diamond letter (default: first letter of the label) */
+        readonly letter: OptionType<StringType>;
+        /** Owning role / system ("sort-planner") */
+        readonly owner: OptionType<StringType>;
+        /** State keys queued at the decision */
+        readonly queue: OptionType<ArrayType<StringType>>;
+        /** Outcome summary line ("CH* (×14 chutes)") */
+        readonly outcomes: OptionType<StringType>;
+    }>>;
+}>;
+/**
+ * Type representing one flow.
+ */
+export type FlowchartFlowType = typeof FlowchartFlowType;
+/**
+ * A record of flows, by name — the record a flowchart is bound to (#1244,
+ * `Flowchart Builder Spec.md` §5.1): a record always holds flows by name, e3's
+ * patch mutation writing only keyed records. A name is the flow's key in the
+ * record. `Flowchart.values` writes one from literals.
+ */
+export declare const FlowchartFlowsType: DictType<StringType, StructType<{
+    /** One sentence about the flow: the line its card in the Flows tab shows */
+    readonly description: OptionType<StringType>;
+    /** Its lanes, in band order */
+    readonly lanes: ArrayType<StructType<{
+        /** Lane identity referenced by states */
+        readonly key: StringType;
+        /** Band header label (defaults to the key, uppercased) */
+        readonly label: OptionType<StringType>;
+    }>>;
+    /** Its states, each in one of its lanes */
+    readonly states: ArrayType<StructType<{
+        /** Short mono code — the node identity ("IND") */
+        readonly key: StringType;
+        /** Display label under the code */
+        readonly label: OptionType<StringType>;
+        /** The lane (ordered phase) this state belongs to */
+        readonly lane: StringType;
+        /** State-class member count → the ×N badge */
+        readonly members: OptionType<IntegerType>;
+        /** Free-text notes, shown and edited in the inspector */
+        readonly notes: OptionType<StringType>;
+    }>>;
+    /** Its transitions; one naming a state the flow does not have draws as the unresolved ghost */
+    readonly links: ArrayType<StructType<{
+        /** Stable identity (selection / delete events); default derived from endpoints */
+        readonly key: OptionType<StringType>;
+        /** Source state key */
+        readonly from: StringType;
+        /** Target state key */
+        readonly to: StringType;
+        /** planned (default) | observed */
+        readonly kind: OptionType<VariantType<{
+            /** A designed / expected transition (solid stroke) */
+            readonly planned: NullType;
+            /** A transition mined from evidence (dashed stroke) */
+            readonly observed: NullType;
+        }>>;
+        /** 0..1 decision trigger key → diamond */
+        readonly trigger: OptionType<StringType>;
+        /** Imported evidence (weight, badges, provenance) */
+        readonly evidence: OptionType<StructType<{
+            /** Total measured volume behind the arrow */
+            readonly volume: OptionType<FloatType>;
+            /** Event count behind the arrow (e.g. cage moves) */
+            readonly count: OptionType<IntegerType>;
+            /** When the evidence was measured */
+            readonly measuredAt: OptionType<DateTimeType>;
+            /** Volume unit suffix for badges ("parcels") */
+            readonly unit: OptionType<StringType>;
+        }>>;
+    }>>;
+    /** Its decisions, each named by the transitions it governs */
+    readonly triggers: ArrayType<StructType<{
+        /** Trigger identity referenced by links */
+        readonly key: StringType;
+        /** Decision name ("route") */
+        readonly label: StringType;
+        /** Diamond letter (default: first letter of the label) */
+        readonly letter: OptionType<StringType>;
+        /** Owning role / system ("sort-planner") */
+        readonly owner: OptionType<StringType>;
+        /** State keys queued at the decision */
+        readonly queue: OptionType<ArrayType<StringType>>;
+        /** Outcome summary line ("CH* (×14 chutes)") */
+        readonly outcomes: OptionType<StringType>;
+    }>>;
+}>>;
+/**
+ * Type representing a record of flows.
+ */
+export type FlowchartFlowsType = typeof FlowchartFlowsType;
+/**
+ * Eyebrow freshness chip content.
+ *
+ * @property label - Chip label ("evidence-2026.06")
+ * @property date - Optional stamp printed after the label
+ */
+export declare const FlowchartFreshnessType: StructType<{
+    /** Chip label ("evidence-2026.06") */
+    readonly label: StringType;
+    /** Optional stamp printed after the label */
+    readonly date: OptionType<DateTimeType>;
+}>;
+/**
+ * Type representing the freshness chip.
+ */
+export type FlowchartFreshnessType = typeof FlowchartFreshnessType;
+//# sourceMappingURL=types.d.ts.map

package/dist/src/flowchart/types.d.ts.map

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

package/dist/src/flowchart/types.js

@@ -0,0 +1,216 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+import { ArrayType, DateTimeType, DictType, FloatType, IntegerType, NullType, OptionType, StringType, StructType, VariantType, } from "@elaraai/east";
+/**
+ * Link kind — the transition's provenance class.
+ *
+ * @remarks
+ * `planned` renders solid; `observed` renders dashed (5/4). A link whose
+ * `from` / `to` reference has no state row is *unresolved* — that is a
+ * derived render class (dashed 4/4 in the negative tone against a ghost
+ * "No state row" node), never an authored kind.
+ *
+ * @property planned - A designed / expected transition (solid stroke)
+ * @property observed - A transition mined from evidence (dashed stroke)
+ */
+export const FlowchartLinkKindType = VariantType({
+    /** A designed / expected transition (solid stroke) */
+    planned: NullType,
+    /** A transition mined from evidence (dashed stroke) */
+    observed: NullType,
+});
+/**
+ * Canvas orientation — which axis the lane bands run along.
+ *
+ * @remarks
+ * Orientation is VIEW state, not slice state: the eyebrow's orientation
+ * segment toggles it and it never appears as a filter chip. `LR` lays
+ * lanes left→right (links flow rightward); `TD` swaps the axes.
+ *
+ * @property LR - Lanes run left → right
+ * @property TD - Lanes run top → down
+ */
+export const FlowchartOrientationType = VariantType({
+    /** Lanes run left → right */
+    LR: NullType,
+    /** Lanes run top → down */
+    TD: NullType,
+});
+/**
+ * Imported evidence carried by a link — never hand-authored.
+ *
+ * @remarks
+ * Evidence drives derived marks only: stroke weight scales with `volume`
+ * (log scale 1.6 / 2 / 2.5 px, floor 1.4), `volume` + `unit` print as the
+ * paper-filled badge on the longest straight run, and the inspector shows
+ * all four, read only, under the transition's fields (#1250).
+ *
+ * @property volume - Total measured volume behind the arrow
+ * @property count - Event count behind the arrow (e.g. cage moves)
+ * @property measuredAt - When the evidence was measured
+ * @property unit - Volume unit suffix for badges ("parcels")
+ */
+export const FlowchartEvidenceType = StructType({
+    /** Total measured volume behind the arrow */
+    volume: OptionType(FloatType),
+    /** Event count behind the arrow (e.g. cage moves) */
+    count: OptionType(IntegerType),
+    /** When the evidence was measured */
+    measuredAt: OptionType(DateTimeType),
+    /** Volume unit suffix for badges ("parcels") */
+    unit: OptionType(StringType),
+});
+/**
+ * One state — a node in the flowchart.
+ *
+ * @remarks
+ * The short mono `key` is the node identity everywhere (selection events,
+ * link `from` / `to` refs, trigger queues). A state with `members` set is
+ * a STATE CLASS — one node standing for N interchangeable members (the
+ * `×N` badge). In-place transitions (`from == to` links) collapse to the
+ * `↻ n` badge on the node and never route through handles.
+ *
+ * @property key - Short mono code — the node identity ("IND")
+ * @property label - Display label under the code
+ * @property lane - The lane (ordered phase) this state belongs to
+ * @property members - State-class member count → the ×N badge
+ * @property notes - Free-text notes, shown and edited in the inspector
+ */
+export const FlowchartStateType = StructType({
+    /** Short mono code — the node identity ("IND") */
+    key: StringType,
+    /** Display label under the code */
+    label: OptionType(StringType),
+    /** The lane (ordered phase) this state belongs to */
+    lane: StringType,
+    /** State-class member count → the ×N badge */
+    members: OptionType(IntegerType),
+    /** Free-text notes, shown and edited in the inspector */
+    notes: OptionType(StringType),
+});
+/**
+ * One link — a state transition drawn as an H/V-routed arrow.
+ *
+ * @remarks
+ * `from` / `to` are state keys; a reference with no state row renders the
+ * neg-dashed ghost "No state row" node (derived, counted in the footer).
+ * At most one `trigger` per link — the lettered decision diamond anchored
+ * to the midpoint of the longest straight run.
+ *
+ * @property key - Stable identity (selection / delete events); default derived from endpoints
+ * @property from - Source state key
+ * @property to - Target state key
+ * @property kind - planned (default) | observed
+ * @property trigger - 0..1 decision trigger key → diamond
+ * @property evidence - Imported evidence (weight, badges, provenance)
+ */
+export const FlowchartLinkType = StructType({
+    /** Stable identity (selection / delete events); default derived from endpoints */
+    key: OptionType(StringType),
+    /** Source state key */
+    from: StringType,
+    /** Target state key */
+    to: StringType,
+    /** planned (default) | observed */
+    kind: OptionType(FlowchartLinkKindType),
+    /** 0..1 decision trigger key → diamond */
+    trigger: OptionType(StringType),
+    /** Imported evidence (weight, badges, provenance) */
+    evidence: OptionType(FlowchartEvidenceType),
+});
+/**
+ * One lane — an ordered phase band.
+ *
+ * @remarks
+ * Lane order is array order; every state names its lane by `key`. The
+ * dashed `+ LANE` affordance renders at the tail of the band row.
+ *
+ * @property key - Lane identity referenced by states
+ * @property label - Band header label (defaults to the key, uppercased)
+ */
+export const FlowchartLaneType = StructType({
+    /** Lane identity referenced by states */
+    key: StringType,
+    /** Band header label (defaults to the key, uppercased) */
+    label: OptionType(StringType),
+});
+/**
+ * One decision trigger — a governed decision seam referenced by links.
+ *
+ * @remarks
+ * Triggers render as diamonds (max one per link) carrying a letter per
+ * TYPE, not per instance. Clicking a diamond highlights every link it
+ * governs (plus queue and outcome nodes).
+ *
+ * @property key - Trigger identity referenced by links
+ * @property label - Decision name ("route")
+ * @property letter - Diamond letter (default: first letter of the label)
+ * @property owner - Owning role / system ("sort-planner")
+ * @property queue - State keys queued at the decision
+ * @property outcomes - Outcome summary line ("CH* (×14 chutes)")
+ */
+export const FlowchartTriggerType = StructType({
+    /** Trigger identity referenced by links */
+    key: StringType,
+    /** Decision name ("route") */
+    label: StringType,
+    /** Diamond letter (default: first letter of the label) */
+    letter: OptionType(StringType),
+    /** Owning role / system ("sort-planner") */
+    owner: OptionType(StringType),
+    /** State keys queued at the decision */
+    queue: OptionType(ArrayType(StringType)),
+    /** Outcome summary line ("CH* (×14 chutes)") */
+    outcomes: OptionType(StringType),
+});
+/**
+ * One flow — a whole flowchart: its lanes, its states, the transitions
+ * between them and the decisions that govern them (#1244, `Flowchart Builder
+ * Spec.md` §5.1).
+ *
+ * @remarks
+ * A record of flows holds one per name ({@link FlowchartFlowsType}), and a
+ * lone flow is a record of one entry, or the host's `data`. `Flowchart.value`
+ * writes one from a literal, and `Flowchart.over` builds one from an app's
+ * own tables. A record's entries are flows, so it is a stored form.
+ *
+ * @property description - One sentence about the flow: the line its card in the Flows tab shows
+ * @property lanes - Its lanes, in band order
+ * @property states - Its states, each in one of its lanes
+ * @property links - Its transitions; one naming a state the flow does not have draws as the unresolved ghost
+ * @property triggers - Its decisions, each named by the transitions it governs
+ */
+export const FlowchartFlowType = StructType({
+    /** One sentence about the flow: the line its card in the Flows tab shows */
+    description: OptionType(StringType),
+    /** Its lanes, in band order */
+    lanes: ArrayType(FlowchartLaneType),
+    /** Its states, each in one of its lanes */
+    states: ArrayType(FlowchartStateType),
+    /** Its transitions; one naming a state the flow does not have draws as the unresolved ghost */
+    links: ArrayType(FlowchartLinkType),
+    /** Its decisions, each named by the transitions it governs */
+    triggers: ArrayType(FlowchartTriggerType),
+});
+/**
+ * A record of flows, by name — the record a flowchart is bound to (#1244,
+ * `Flowchart Builder Spec.md` §5.1): a record always holds flows by name, e3's
+ * patch mutation writing only keyed records. A name is the flow's key in the
+ * record. `Flowchart.values` writes one from literals.
+ */
+export const FlowchartFlowsType = DictType(StringType, FlowchartFlowType);
+/**
+ * Eyebrow freshness chip content.
+ *
+ * @property label - Chip label ("evidence-2026.06")
+ * @property date - Optional stamp printed after the label
+ */
+export const FlowchartFreshnessType = StructType({
+    /** Chip label ("evidence-2026.06") */
+    label: StringType,
+    /** Optional stamp printed after the label */
+    date: OptionType(DateTimeType),
+});
+//# sourceMappingURL=types.js.map

package/dist/src/flowchart/types.js.map

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