@graphrefly/ts 0.0.1 → 0.0.3

package/dist/types-ePlD2uyT.d.ts

@@ -0,0 +1,457 @@
+import { DataIssue } from './data/index.js';
+import { d as Graph } from './graph-CS0b4V9B.js';
+import { N as Node } from './types-DChxk1vK.js';
+
+/**
+ * Synchronous text measurement contract for the D181 reactive-layout solution core.
+ *
+ * Implementations are injected by the caller; the universal subpath never imports DOM,
+ * Canvas, React Native, storage, GraphSpec, or async image loading.
+ */
+interface MeasurementAdapter {
+    measureSegment(text: string, font: string): {
+        readonly width: number;
+    };
+    clearCache?(): void;
+}
+/** Caller-owned platform text capability, for NodeCanvas/Skia/RN-style wrappers. */
+interface TextMeasureCapability {
+    measureText(text: string, font: string): number | {
+        readonly width: number;
+    };
+    clearCache?(): void;
+}
+/** One text segment returned by a caller-provided segmenter. */
+interface SegmentInfo {
+    readonly segment: string;
+    readonly index: number;
+    readonly isWordLike?: boolean;
+}
+/** Synchronous word/grapheme segmentation contract for hosts without Intl.Segmenter. */
+interface SegmentAdapter {
+    segmentWords(text: string): Iterable<SegmentInfo>;
+    segmentGraphemes(text: string): Iterable<SegmentInfo>;
+}
+/** Layout segment class used by the line breaker. */
+type SegmentBreakKind = "text" | "space" | "zero-width-break" | "soft-hyphen" | "hard-break";
+/** Measured text run consumed by pure line/block/flow helpers. */
+interface PreparedSegment {
+    readonly text: string;
+    readonly width: number;
+    readonly kind: SegmentBreakKind;
+    readonly graphemeWidths: readonly number[] | null;
+}
+/** One laid-out line with segment/grapheme cursor bounds. */
+interface LayoutLine {
+    readonly text: string;
+    readonly width: number;
+    readonly startSegment: number;
+    readonly startGrapheme: number;
+    readonly endSegment: number;
+    readonly endGrapheme: number;
+}
+/** Positioned grapheme box for hit testing or custom renderers. */
+interface CharPosition {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+    readonly line: number;
+}
+/** Result emitted by `reactiveLayout().lineBreaks`. */
+interface LineBreaksResult {
+    readonly lines: readonly LayoutLine[];
+    readonly lineCount: number;
+}
+/** Cursor into a prepared segment array. */
+interface LayoutCursor {
+    readonly segmentIndex: number;
+    readonly graphemeIndex: number;
+}
+/** Pure helper result for one `layoutNextLine` step. */
+interface LayoutNextLineResult {
+    readonly text: string;
+    readonly width: number;
+    readonly start: LayoutCursor;
+    readonly end: LayoutCursor;
+}
+/** Horizontal interval used by obstacle carving. */
+interface Interval {
+    readonly left: number;
+    readonly right: number;
+}
+declare const TEXT_SEGMENTS_MEASUREMENT_KIND = "text-segments";
+declare const BLOCKS_MEASUREMENT_KIND = "blocks";
+/** Measurement kind for standalone readiness facts. */
+declare const READINESS_MEASUREMENT_KIND = "readiness";
+/** Measurement kind for standalone image-size facts. */
+declare const IMAGE_SIZE_MEASUREMENT_KIND = "image-size";
+/** Measurement kind for standalone SVG-bounds facts. */
+declare const SVG_BOUNDS_MEASUREMENT_KIND = "svg-bounds";
+interface TextSegmentsMeasurement {
+    readonly segments: readonly PreparedSegment[];
+    readonly hyphenWidth?: number;
+}
+interface BlocksMeasurement {
+    readonly blocks: readonly MeasuredBlock[];
+}
+interface MeasurementResult<T = unknown> {
+    readonly kind: "ok";
+    readonly targetId: string;
+    readonly measurementKind: string;
+    readonly value: T;
+    readonly source?: string;
+    readonly metadata?: Record<string, unknown>;
+}
+interface MeasurementIssue extends DataIssue {
+    readonly subjectId: string;
+    readonly measurementKind: string;
+}
+type MeasurementFact<T = unknown> = MeasurementResult<T> | MeasurementIssue;
+type Measurements = readonly MeasurementFact[];
+interface MergeMeasurementsOptions {
+    readonly graph: Graph;
+    readonly sources: readonly Node<Measurements>[];
+    readonly name?: string;
+}
+interface TextMeasurementProviderOptions {
+    readonly graph: Graph;
+    readonly text: Node<string>;
+    readonly font: Node<string>;
+    readonly adapter: Node<MeasurementAdapter>;
+    readonly segmentAdapter?: Node<SegmentAdapter>;
+    readonly targetId?: string;
+    readonly source?: string;
+    readonly name?: string;
+}
+interface InjectedTextMeasurementsOptions extends Omit<TextMeasurementProviderOptions, "adapter"> {
+    readonly measure: MeasureFn;
+    readonly cache?: boolean;
+}
+interface PrecomputedTextMeasurementsOptions extends Omit<TextMeasurementProviderOptions, "adapter">, PrecomputedMeasureAdapterOptions {
+}
+interface CellTextMeasurementsOptions extends Omit<TextMeasurementProviderOptions, "adapter">, CellMeasureAdapterOptions {
+}
+interface CapabilityTextMeasurementsOptions extends Omit<TextMeasurementProviderOptions, "adapter"> {
+    readonly capability: Node<TextMeasureCapability>;
+}
+interface MeasurementReadiness {
+    readonly ready: boolean;
+    readonly code?: string;
+    readonly message?: string;
+    readonly source?: string;
+    readonly details?: unknown;
+    readonly metadata?: Record<string, unknown>;
+}
+/** Options for projecting readiness into graph-visible measurement facts. */
+interface ReadinessMeasurementsOptions {
+    readonly graph: Graph;
+    readonly readiness: Node<MeasurementReadiness>;
+    readonly targetId?: string;
+    readonly measurementKind?: string;
+    readonly source?: string;
+    readonly name?: string;
+}
+interface ReadinessTextMeasurementsOptions extends TextMeasurementProviderOptions {
+    readonly readiness: Node<MeasurementReadiness>;
+}
+/** Minimal caller-owned lookup for explicit image sizes. */
+interface ImageSizeLookup {
+    get(src: string): Size | undefined;
+}
+/** One image-size fact target for `imageSizeMeasurements`. */
+interface ImageSizeMeasurementTarget {
+    readonly id?: string;
+    readonly src: string;
+    readonly metadata?: Record<string, unknown>;
+}
+/** Options for projecting image-size facts from a caller-owned synchronous measurer. */
+interface ImageSizeMeasurementsOptions {
+    readonly graph: Graph;
+    readonly images: Node<readonly ImageSizeMeasurementTarget[]>;
+    readonly measurer: Node<ImageMeasurer>;
+    readonly measurementKind?: string;
+    readonly source?: string;
+    readonly name?: string;
+}
+/** One SVG-bounds fact target for `svgBoundsMeasurements`. */
+interface SvgBoundsMeasurementTarget {
+    readonly id?: string;
+    readonly svg: string;
+    readonly metadata?: Record<string, unknown>;
+}
+/** Options for projecting SVG bounds from a caller-owned synchronous measurer. */
+interface SvgBoundsMeasurementsOptions {
+    readonly graph: Graph;
+    readonly svgs: Node<readonly SvgBoundsMeasurementTarget[]>;
+    readonly measurer: Node<SvgMeasurer>;
+    readonly measurementKind?: string;
+    readonly source?: string;
+    readonly name?: string;
+}
+interface BlockMeasurementProviderOptions {
+    readonly graph: Graph;
+    readonly blocks: Node<readonly ContentBlock[]>;
+    readonly maxWidth: Node<number>;
+    readonly adapters: Node<BlockAdapters>;
+    readonly segmentAdapter?: Node<SegmentAdapter>;
+    readonly font?: Node<string>;
+    readonly lineHeight?: Node<number>;
+    readonly targetId?: string;
+    readonly source?: string;
+    readonly name?: string;
+}
+interface BlockAdaptersProviderOptions {
+    readonly graph: Graph;
+    readonly text?: Node<MeasurementAdapter>;
+    readonly svg?: Node<SvgMeasurer>;
+    readonly image?: Node<ImageMeasurer>;
+    readonly name?: string;
+}
+/**
+ * Graph-visible bundle returned by `reactiveLayout`.
+ *
+ * The setters are state-node sugar over real graph inputs; the output nodes are ordinary
+ * inspectable nodes visible through `graph.describe()`.
+ */
+interface ReactiveLayoutBundle {
+    readonly graph: Graph;
+    readonly input: {
+        readonly lineHeight: Node<number>;
+        readonly maxWidth: Node<number>;
+        readonly measurements: Node<Measurements>;
+    };
+    setLineHeight(lineHeight: number): void;
+    setMaxWidth(maxWidth: number): void;
+    readonly segments: Node<readonly PreparedSegment[]>;
+    readonly lineBreaks: Node<LineBreaksResult>;
+    readonly height: Node<number>;
+    readonly charPositions: Node<readonly CharPosition[]>;
+}
+/** Optional context shared by pure line-breaking helpers. */
+interface LayoutNextLineContext {
+    readonly adapter?: MeasurementAdapter;
+    readonly font?: string;
+    readonly cache?: Map<string, Map<string, number>>;
+    readonly hyphenWidth?: number;
+    readonly segmentAdapter?: SegmentAdapter;
+}
+/** Cache accounting object callers can pass into `analyzeAndMeasure`. */
+interface SegmentMeasureStats {
+    hits: number;
+    misses: number;
+}
+/** Options for the single-column reactive text layout bundle. */
+interface ReactiveLayoutOptions {
+    readonly measurements: Node<Measurements>;
+    readonly graph: Graph;
+    readonly segmentAdapter?: SegmentAdapter;
+    readonly targetId?: string;
+    readonly name?: string;
+    readonly lineHeight?: number | Node<number>;
+    readonly maxWidth?: number | Node<number>;
+}
+/** Host text measurement function accepted by `InjectedMeasureAdapter`. */
+type MeasureFn = (text: string, font: string) => number | {
+    readonly width: number;
+};
+/** Options for caller-injected synchronous measurement. */
+interface InjectedMeasureAdapterOptions {
+    readonly cache?: boolean;
+}
+/** Options for deterministic precomputed text metrics. */
+interface PrecomputedMeasureAdapterOptions {
+    readonly metrics: ReadonlyMap<string, number> | Record<string, number>;
+    readonly fallback?: "per-char" | "error";
+    readonly cellWidth?: number;
+}
+/** Fixed-cell measurement options for terminal/snapshot rendering. */
+interface CellMeasureAdapterOptions {
+    readonly cellWidth?: number;
+    readonly wideCellWidth?: number;
+    readonly tabCells?: number;
+}
+/** Width/height pair in CSS-like pixels. */
+interface Size {
+    readonly width: number;
+    readonly height: number;
+}
+/** Synchronous SVG measurement seam; no DOM parser is provided by the core. */
+interface SvgMeasurer {
+    measureSvg(svg: string): Size;
+}
+/** Synchronous image measurement seam; no loading/fetching is provided by the core. */
+interface ImageMeasurer {
+    measureImage(src: string): Size;
+}
+/** Optional per-kind block measurement adapters. */
+interface BlockAdapters {
+    readonly text?: MeasurementAdapter;
+    readonly svg?: SvgMeasurer;
+    readonly image?: ImageMeasurer;
+}
+/** Shared spacing/id fields for block layout inputs. */
+interface BaseContentBlock {
+    readonly id?: string;
+    readonly marginTop?: number;
+    readonly marginBottom?: number;
+}
+/** Text block input for `measureBlock` and `reactiveBlockLayout`. */
+interface TextContentBlock extends BaseContentBlock {
+    readonly kind: "text";
+    readonly text: string;
+    readonly font?: string;
+    readonly lineHeight?: number;
+    readonly maxWidth?: number;
+}
+/** Image block input with explicit dimensions or an injected `ImageMeasurer`. */
+interface ImageContentBlock extends BaseContentBlock {
+    readonly kind: "image";
+    readonly src: string;
+    readonly width?: number;
+    readonly height?: number;
+    readonly maxWidth?: number;
+}
+/** SVG block input with explicit dimensions or an injected `SvgMeasurer`. */
+interface SvgContentBlock extends BaseContentBlock {
+    readonly kind: "svg";
+    readonly svg: string;
+    readonly width?: number;
+    readonly height?: number;
+    readonly maxWidth?: number;
+}
+/** Heterogeneous block-layout input. */
+type ContentBlock = TextContentBlock | ImageContentBlock | SvgContentBlock;
+/** Measured block produced by `measureBlock` or `measureBlocks`. */
+interface MeasuredBlock {
+    readonly block: ContentBlock;
+    readonly kind: ContentBlock["kind"];
+    readonly id?: string;
+    readonly width: number;
+    readonly height: number;
+    readonly marginTop: number;
+    readonly marginBottom: number;
+    readonly segments?: readonly PreparedSegment[];
+    readonly lineBreaks?: LineBreaksResult;
+    readonly charPositions?: readonly CharPosition[];
+}
+/** Block with vertical-flow coordinates. */
+interface PositionedBlock extends MeasuredBlock {
+    readonly x: number;
+    readonly y: number;
+}
+/** Options for pure block measurement helpers. */
+interface MeasureBlockOptions {
+    readonly adapter?: MeasurementAdapter;
+    readonly adapters?: BlockAdapters;
+    readonly font?: string;
+    readonly lineHeight?: number;
+    readonly maxWidth?: number;
+    readonly cache?: Map<string, Map<string, number>>;
+    readonly hyphenWidth?: number;
+    readonly segmentAdapter?: SegmentAdapter;
+}
+/** Options for the graph-visible block layout bundle. */
+interface ReactiveBlockLayoutOptions {
+    readonly measurements: Node<Measurements>;
+    readonly graph: Graph;
+    readonly targetId?: string;
+    readonly name?: string;
+    readonly gap?: number | Node<number>;
+}
+/** Graph-visible vertical block layout bundle. */
+interface ReactiveBlockLayoutBundle {
+    readonly graph: Graph;
+    readonly input: {
+        readonly gap: Node<number>;
+        readonly measurements: Node<Measurements>;
+    };
+    setGap(gap: number): void;
+    readonly measuredBlocks: Node<readonly MeasuredBlock[]>;
+    readonly blockFlow: Node<readonly PositionedBlock[]>;
+    readonly totalHeight: Node<number>;
+}
+/** Circular obstacle for flow layout slot carving. */
+interface CircleObstacle {
+    readonly kind: "circle";
+    readonly cx: number;
+    readonly cy: number;
+    readonly r: number;
+}
+/** Rectangular obstacle for flow layout slot carving. */
+interface RectObstacle {
+    readonly kind: "rect";
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+/** Obstacle shape accepted by flow layout. */
+type Obstacle = CircleObstacle | RectObstacle;
+/** Flow container geometry. */
+interface FlowContainer {
+    readonly width: number;
+    readonly height: number;
+    readonly paddingX?: number;
+    readonly paddingY?: number;
+}
+/** Optional column geometry for flow layout. */
+interface FlowColumns {
+    readonly count?: number;
+    readonly gap?: number;
+}
+/** Positioned line emitted by `computeFlowLines` / `reactiveFlowLayout`. */
+interface PositionedLine extends LayoutLine {
+    readonly x: number;
+    readonly y: number;
+    readonly slotWidth: number;
+    readonly columnIndex: number;
+}
+/** Flow layout result plus the continuation cursor. */
+interface FlowLinesResult {
+    readonly lines: readonly PositionedLine[];
+    readonly cursor: LayoutCursor;
+    readonly done: boolean;
+}
+/** Options for pure flow layout computation. */
+interface ComputeFlowLinesOptions {
+    readonly container: FlowContainer;
+    readonly columns?: FlowColumns;
+    readonly obstacles?: readonly Obstacle[];
+    readonly lineHeight: number;
+    readonly minSlotWidth?: number;
+    readonly hyphenWidth?: number;
+    readonly segmentAdapter?: SegmentAdapter;
+}
+/** Options for the graph-visible flow layout bundle. */
+interface ReactiveFlowLayoutOptions {
+    readonly measurements: Node<Measurements>;
+    readonly graph: Graph;
+    readonly segmentAdapter?: SegmentAdapter;
+    readonly targetId?: string;
+    readonly name?: string;
+    readonly lineHeight?: number | Node<number>;
+    readonly container?: FlowContainer | Node<FlowContainer>;
+    readonly columns?: FlowColumns | Node<FlowColumns>;
+    readonly obstacles?: readonly Obstacle[] | Node<readonly Obstacle[]>;
+    readonly minSlotWidth?: number;
+}
+/** Graph-visible multi-column flow layout bundle. */
+interface ReactiveFlowLayoutBundle {
+    readonly graph: Graph;
+    readonly input: {
+        readonly lineHeight: Node<number>;
+        readonly container: Node<FlowContainer>;
+        readonly columns: Node<FlowColumns>;
+        readonly obstacles: Node<readonly Obstacle[]>;
+        readonly measurements: Node<Measurements>;
+    };
+    setLineHeight(lineHeight: number): void;
+    setContainer(container: FlowContainer): void;
+    setColumns(columns: FlowColumns): void;
+    setObstacles(obstacles: readonly Obstacle[]): void;
+    readonly segments: Node<readonly PreparedSegment[]>;
+    readonly flowLines: Node<FlowLinesResult>;
+}
+
+export { type RectObstacle as $, type MeasurementFact as A, BLOCKS_MEASUREMENT_KIND as B, type CapabilityTextMeasurementsOptions as C, type MeasurementIssue as D, type MeasurementReadiness as E, type FlowColumns as F, type MeasurementResult as G, type Measurements as H, IMAGE_SIZE_MEASUREMENT_KIND as I, type MergeMeasurementsOptions as J, type PositionedLine as K, type LayoutCursor as L, type MeasureBlockOptions as M, type PrecomputedMeasureAdapterOptions as N, type Obstacle as O, type PositionedBlock as P, type PrecomputedTextMeasurementsOptions as Q, type PreparedSegment as R, READINESS_MEASUREMENT_KIND as S, type ReactiveBlockLayoutBundle as T, type ReactiveBlockLayoutOptions as U, type ReactiveFlowLayoutBundle as V, type ReactiveFlowLayoutOptions as W, type ReactiveLayoutBundle as X, type ReactiveLayoutOptions as Y, type ReadinessMeasurementsOptions as Z, type ReadinessTextMeasurementsOptions as _, type BaseContentBlock as a, SVG_BOUNDS_MEASUREMENT_KIND as a0, type SegmentAdapter as a1, type SegmentBreakKind as a2, type SegmentInfo as a3, type SegmentMeasureStats as a4, type Size as a5, type SvgBoundsMeasurementTarget as a6, type SvgBoundsMeasurementsOptions as a7, type SvgContentBlock as a8, type SvgMeasurer as a9, TEXT_SEGMENTS_MEASUREMENT_KIND as aa, type TextContentBlock as ab, type TextMeasureCapability as ac, type TextMeasurementProviderOptions as ad, type TextSegmentsMeasurement as ae, type CharPosition as af, type Interval as ag, type BlockAdapters as b, type BlockAdaptersProviderOptions as c, type BlockMeasurementProviderOptions as d, type BlocksMeasurement as e, type CellMeasureAdapterOptions as f, type CellTextMeasurementsOptions as g, type CircleObstacle as h, type ComputeFlowLinesOptions as i, type ContentBlock as j, type FlowContainer as k, type FlowLinesResult as l, type ImageContentBlock as m, type ImageMeasurer as n, type ImageSizeLookup as o, type ImageSizeMeasurementTarget as p, type ImageSizeMeasurementsOptions as q, type InjectedMeasureAdapterOptions as r, type InjectedTextMeasurementsOptions as s, type LayoutLine as t, type LayoutNextLineContext as u, type LayoutNextLineResult as v, type LineBreaksResult as w, type MeasureFn as x, type MeasuredBlock as y, type MeasurementAdapter as z };

package/dist/{work-item-runtime-qaVgsL0T.d.cts → work-item-runtime-types-BTxLskN5.d.cts}

@@ -1,19 +1,7 @@
 import { DataIssue } from './data/index.cjs';
-import { d as Graph } from './graph-DCEWh4T2.cjs';
-import { N as Node } from './types-CcPIn7sy.cjs';
-import { S as SourceRef, v as AgentRuntimeAuditRecord, H as EffectRunResultStatus, z as EffectRunGoal, B as EffectRunLimits, w as EffectRun, h as AgentOutputEnvelope, g as AgentNeed, F as EffectRunResult } from './agent-runtime-DZTJ3C-p.cjs';
+import { N as Node } from './types-CTN3XoMl.cjs';
+import { S as SourceRef, a as AgentRuntimeAuditRecord, k as EffectRunResultStatus, l as EffectRunGoal, m as EffectRunLimits, h as AgentOutputEnvelope, j as AgentNeed } from './agent-runtime-types-core-bfl4m0vM.cjs';
 
-interface WorkItemSeed {
-    readonly kind: "work-item";
-    readonly workItemId: string;
-    readonly sourceRefs?: readonly SourceRef[];
-    readonly workItemKind?: string;
-    readonly summary?: string;
-    readonly detailRef?: string;
-    readonly lifecycleStatus?: string;
-    readonly issues?: readonly DataIssue[];
-    readonly metadata?: Record<string, unknown>;
-}
 interface WorkItemEffectRequested<TInput = unknown> {
     readonly kind: "work-item-effect-requested";
     readonly requestId: string;
@@ -120,16 +108,6 @@ interface WorkItemDomainActionAdmission {
     readonly admittedAtMs?: number;
     readonly metadata?: Record<string, unknown>;
 }
-interface WorkItemEffectMappingPolicy {
-    readonly kind: "work-item-effect-mapping-policy";
-    readonly policyId: string;
-    readonly effectKinds?: readonly string[];
-    readonly evidence?: {
-        readonly behavior?: "record";
-    };
-    readonly actionProposals?: readonly WorkItemDomainActionProposalSpec[];
-    readonly metadata?: Record<string, unknown>;
-}
 interface WorkItemStatusRecord {
     readonly kind: "work-item-status";
     readonly statusId: string;
@@ -143,51 +121,12 @@ interface WorkItemStatusRecord {
     readonly issues?: readonly DataIssue[];
     readonly metadata?: Record<string, unknown>;
 }
-interface WorkItemEffectRequestViews {
-    readonly pendingEffectRequests: readonly WorkItemEffectRequested[];
-    readonly issues: readonly DataIssue[];
-    readonly audit: readonly AgentRuntimeAuditRecord[];
-}
-interface WorkItemEvidenceViews {
-    readonly evidenceByWorkItem: ReadonlyMap<string, readonly WorkItemEvidenceRecorded[]>;
-    readonly latestEvidenceByEffectRun: ReadonlyMap<string, WorkItemEvidenceRecorded>;
-    readonly issues: readonly DataIssue[];
-    readonly audit: readonly AgentRuntimeAuditRecord[];
-    readonly pendingEffectRequests: readonly WorkItemEffectRequested[];
-}
-interface WorkItemDomainActionProposalViews {
-    readonly proposalsByWorkItem: ReadonlyMap<string, readonly WorkItemDomainActionProposal[]>;
-    readonly proposalsByEvidence: ReadonlyMap<string, readonly WorkItemDomainActionProposal[]>;
-    readonly issues: readonly DataIssue[];
-    readonly audit: readonly AgentRuntimeAuditRecord[];
-}
 interface WorkItemDomainActionAdmissionViews {
     readonly admissionsByProposal: ReadonlyMap<string, WorkItemDomainActionAdmission>;
     readonly admissionsByWorkItem: ReadonlyMap<string, readonly WorkItemDomainActionAdmission[]>;
     readonly issues: readonly DataIssue[];
     readonly audit: readonly AgentRuntimeAuditRecord[];
 }
-interface WorkItemEffectRunBundle {
-    readonly effectRuns: Node<EffectRun>;
-    readonly status: Node<WorkItemStatusRecord>;
-    readonly issues: Node<DataIssue>;
-    readonly audit: Node<AgentRuntimeAuditRecord>;
-    readonly views: Node<WorkItemEffectRequestViews>;
-}
-interface WorkItemEvidenceMapperBundle {
-    readonly evidence: Node<WorkItemEvidenceRecorded>;
-    readonly status: Node<WorkItemStatusRecord>;
-    readonly issues: Node<DataIssue>;
-    readonly audit: Node<AgentRuntimeAuditRecord>;
-    readonly views: Node<WorkItemEvidenceViews>;
-}
-interface WorkItemDomainActionProposalBundle {
-    readonly proposals: Node<WorkItemDomainActionProposal>;
-    readonly status: Node<WorkItemStatusRecord>;
-    readonly issues: Node<DataIssue>;
-    readonly audit: Node<AgentRuntimeAuditRecord>;
-    readonly views: Node<WorkItemDomainActionProposalViews>;
-}
 interface WorkItemDomainActionAdmissionBundle {
     readonly admissions: Node<WorkItemDomainActionAdmission>;
     readonly status: Node<WorkItemStatusRecord>;
@@ -195,34 +134,5 @@ interface WorkItemDomainActionAdmissionBundle {
     readonly audit: Node<AgentRuntimeAuditRecord>;
     readonly views: Node<WorkItemDomainActionAdmissionViews>;
 }
-declare function workItemEffectRunProjector(graph: Graph, opts: {
-    readonly name?: string;
-    readonly workItems: Node<WorkItemSeed>;
-    readonly effectRequests: Node<WorkItemEffectRequested>;
-}): WorkItemEffectRunBundle;
-declare function workItemEffectResultMapper(graph: Graph, opts: {
-    readonly name?: string;
-    readonly workItems: Node<WorkItemSeed>;
-    readonly effectRuns: Node<EffectRun>;
-    readonly effectRunResults: Node<EffectRunResult>;
-    readonly effectRequests?: Node<WorkItemEffectRequested>;
-    readonly mappingPolicies?: readonly Node<WorkItemEffectMappingPolicy>[];
-    readonly now?: () => number;
-}): WorkItemEvidenceMapperBundle;
-declare function workItemDomainActionProposalProjector(graph: Graph, opts: {
-    readonly name?: string;
-    readonly workItems: Node<WorkItemSeed>;
-    readonly evidence: Node<WorkItemEvidenceRecorded>;
-    readonly effectRunResults: Node<EffectRunResult>;
-    readonly mappingPolicies: readonly Node<WorkItemEffectMappingPolicy>[];
-    readonly now?: () => number;
-}): WorkItemDomainActionProposalBundle;
-declare function workItemDomainActionAdmissionProjector(graph: Graph, opts: {
-    readonly name?: string;
-    readonly proposals: Node<WorkItemDomainActionProposal>;
-    readonly decisions: Node<WorkItemDomainActionAdmissionDecision>;
-    readonly admissionPolicies?: readonly Node<WorkItemDomainActionAdmissionPolicy>[];
-    readonly now?: () => number;
-}): WorkItemDomainActionAdmissionBundle;
 
-export { type WorkItemDomainActionAdmission as W, type WorkItemDomainActionAdmissionBundle as a, type WorkItemDomainActionAdmissionDecision as b, type WorkItemDomainActionAdmissionOutcome as c, type WorkItemDomainActionAdmissionPolicy as d, type WorkItemDomainActionAdmissionState as e, type WorkItemDomainActionAdmissionViews as f, type WorkItemDomainActionProposal as g, type WorkItemDomainActionProposalBundle as h, type WorkItemDomainActionProposalPayloadFrom as i, type WorkItemDomainActionProposalSpec as j, type WorkItemDomainActionProposalViews as k, type WorkItemEffectMappingPolicy as l, type WorkItemEffectRequestViews as m, type WorkItemEffectRequested as n, type WorkItemEffectRunBundle as o, type WorkItemEvidenceMapperBundle as p, type WorkItemEvidenceRecorded as q, type WorkItemEvidenceViews as r, type WorkItemSeed as s, type WorkItemStatusRecord as t, workItemDomainActionProposalProjector as u, workItemEffectResultMapper as v, workItemDomainActionAdmissionProjector as w, workItemEffectRunProjector as x };
+export type { WorkItemEffectRequested as W, WorkItemEvidenceRecorded as a, WorkItemStatusRecord as b, WorkItemDomainActionProposal as c, WorkItemDomainActionProposalSpec as d, WorkItemDomainActionAdmission as e, WorkItemDomainActionAdmissionDecision as f, WorkItemDomainActionAdmissionPolicy as g, WorkItemDomainActionAdmissionBundle as h, WorkItemDomainActionAdmissionViews as i };