@anscribe/core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 msmps
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,11 @@
+# @anscribe/core
+
+> Internal capture model shared by `@anscribe/opentui`, `@anscribe/mcp`, and `@anscribe/react`. **Not part of the public API.**
+
+You almost certainly want [`@anscribe/opentui`](https://www.npmjs.com/package/@anscribe/opentui).
+
+This package exists so the OpenTUI host, the MCP server, and the React enricher can share Schema definitions (`Capture`, `CapturedTarget`, `TerminalCellBounds`, …) and the framework-agnostic Capture Mode state machine without circular dependencies. Its surface is not stabilized; minor releases may break consumers.
+
+## License
+
+MIT © [msmps](https://github.com/msmps)

package/dist/index.d.mts

@@ -0,0 +1,405 @@
+import { Context, Data, Effect, FileSystem, Layer, Path, Schema } from "effect";
+import * as _$effect_Brand0 from "effect/Brand";
+import * as _$effect_Cause0 from "effect/Cause";
+import * as _$effect_Unify0 from "effect/Unify";
+
+//#region src/schema.d.ts
+declare const CaptureId: Schema.brand<Schema.String, "CaptureId">;
+type CaptureId = typeof CaptureId.Type;
+declare const CapturedTargetId: Schema.brand<Schema.String, "CapturedTargetId">;
+type CapturedTargetId = typeof CapturedTargetId.Type;
+declare const generateCaptureId: Effect.Effect<string & _$effect_Brand0.Brand<"CaptureId">, never, never>;
+declare const generateCapturedTargetId: Effect.Effect<string & _$effect_Brand0.Brand<"CapturedTargetId">, never, never>;
+declare function parseIsoTimestampMillis(value: string): number | undefined;
+declare const IsoTimestamp: Schema.brand<Schema.String, "IsoTimestamp">;
+type IsoTimestamp = typeof IsoTimestamp.Type;
+declare const CaptureValidationError_base: Schema.Class<CaptureValidationError, Schema.TaggedStruct<"CaptureValidationError", {
+  readonly message: Schema.String;
+  readonly cause: Schema.optionalKey<Schema.Unknown>;
+}>, _$effect_Cause0.YieldableError>;
+declare class CaptureValidationError extends CaptureValidationError_base {}
+declare const CapturePersistenceError_base: Schema.Class<CapturePersistenceError, Schema.TaggedStruct<"CapturePersistenceError", {
+  readonly message: Schema.String;
+  readonly cause: Schema.optionalKey<Schema.Unknown>;
+}>, _$effect_Cause0.YieldableError>;
+declare class CapturePersistenceError extends CapturePersistenceError_base {}
+declare const TerminalCellBounds_base: Schema.Class<TerminalCellBounds, Schema.Struct<{
+  readonly x: Schema.Finite;
+  readonly y: Schema.Finite;
+  readonly width: Schema.Finite;
+  readonly height: Schema.Finite;
+}>, {}>;
+declare class TerminalCellBounds extends TerminalCellBounds_base {}
+declare const SourceReference_base: Schema.Class<SourceReference, Schema.Struct<{
+  readonly file: Schema.optionalKey<Schema.String>;
+  readonly line: Schema.optionalKey<Schema.Finite>;
+  readonly column: Schema.optionalKey<Schema.Finite>;
+  readonly functionName: Schema.optionalKey<Schema.String>;
+  readonly componentName: Schema.optionalKey<Schema.String>;
+  readonly origin: Schema.optionalKey<Schema.String>;
+}>, {}>;
+declare class SourceReference extends SourceReference_base {}
+declare const CaptureMetadata_base: Schema.Class<CaptureMetadata, Schema.Struct<{
+  readonly identifier: Schema.optionalKey<Schema.String>;
+  readonly componentName: Schema.optionalKey<Schema.String>;
+  readonly componentPath: Schema.optionalKey<Schema.String>;
+}>, {}>;
+declare class CaptureMetadata extends CaptureMetadata_base {}
+type CaptureStatus = "pending" | "resolved";
+declare const captureStatusSchema: Schema.Literals<readonly ["pending", "resolved"]>;
+declare const CapturedTarget_base: Schema.Class<CapturedTarget, Schema.Struct<{
+  readonly id: Schema.brand<Schema.String, "CapturedTargetId">;
+  readonly type: Schema.String;
+  readonly bounds: typeof TerminalCellBounds;
+  readonly ancestry: Schema.$Array<Schema.String>;
+  readonly visibleContent: Schema.optionalKey<Schema.String>;
+  readonly metadata: Schema.optionalKey<typeof CaptureMetadata>;
+  readonly sourceReferences: Schema.optionalKey<Schema.$Array<typeof SourceReference>>;
+}>, {}>;
+declare class CapturedTarget extends CapturedTarget_base {}
+declare const Capture_base: Schema.Class<Capture, Schema.Struct<{
+  readonly id: Schema.brand<Schema.String, "CaptureId">;
+  readonly status: Schema.Literals<readonly ["pending", "resolved"]>;
+  readonly createdAt: Schema.brand<Schema.String, "IsoTimestamp">;
+  readonly instruction: Schema.optionalKey<Schema.String>;
+  readonly targets: Schema.$Array<typeof CapturedTarget>;
+}>, {}>;
+declare class Capture extends Capture_base {}
+type CaptureInput = ConstructorParameters<typeof Capture>[0];
+declare const makeCapture: (input: CaptureInput) => Effect.Effect<Capture, CaptureValidationError, never>;
+declare function decodeAnscribeData<T>(schema: Schema.Schema<T>, input: unknown): T;
+declare const decodeAnscribeDataEffect: <S extends Schema.Top>(schema: S, input: unknown) => Effect.Effect<S["Type"], CaptureValidationError, S["DecodingServices"]>;
+//#endregion
+//#region src/project.d.ts
+declare const CaptureProjectResolutionError_base: Schema.Class<CaptureProjectResolutionError, Schema.TaggedStruct<"CaptureProjectResolutionError", {
+  readonly message: Schema.String;
+  readonly cause: Schema.optionalKey<Schema.Unknown>;
+}>, _$effect_Cause0.YieldableError>;
+declare class CaptureProjectResolutionError extends CaptureProjectResolutionError_base {}
+interface ResolvedCaptureProject {
+  readonly projectRoot: string;
+}
+declare const resolveCaptureProjectBoundary: (cwd: string) => Effect.Effect<ResolvedCaptureProject, CaptureProjectResolutionError, FileSystem.FileSystem | Path.Path>;
+//#endregion
+//#region src/enrichment.d.ts
+interface CaptureEnrichmentOutput {
+  readonly metadata?: CaptureMetadata;
+  readonly sourceReferences?: readonly SourceReference[];
+}
+declare const noCaptureEnrichment: Effect.Effect<CaptureEnrichmentOutput | undefined>;
+type CaptureMetadataEnricher = (input: {
+  renderable: unknown;
+  target: CapturedTarget;
+}) => Effect.Effect<CaptureEnrichmentOutput | undefined>;
+interface CaptureMetadataEnrichmentShape {
+  readonly enrich: CaptureMetadataEnricher;
+}
+declare const CaptureMetadataEnrichment_base: Context.ServiceClass<CaptureMetadataEnrichment, "anscribe/enrichment/CaptureMetadataEnrichment", CaptureMetadataEnrichmentShape>;
+declare class CaptureMetadataEnrichment extends CaptureMetadataEnrichment_base {
+  static readonly live: Layer.Layer<CaptureMetadataEnrichment, never, never>;
+  static readonly layer: (enricher: CaptureMetadataEnricher) => Layer.Layer<CaptureMetadataEnrichment, never, never>;
+}
+//#endregion
+//#region src/picker/state.d.ts
+interface PickerState {
+  readonly active: boolean;
+  readonly targets: readonly CapturedTarget[];
+  readonly currentIndex: number;
+  readonly selectedTargetIds: readonly CapturedTargetId[];
+}
+declare function selectCurrentTarget(state: PickerState): CapturedTarget | undefined;
+declare function resolveTargetAtCell(targets: readonly CapturedTarget[], x: number, y: number): CapturedTarget | undefined;
+//#endregion
+//#region src/capture-mode/state.d.ts
+interface CaptureModeState extends PickerState {
+  readonly instructionDraft: boolean;
+}
+declare const initialState: CaptureModeState;
+type CaptureModeIntent = Data.TaggedEnum<{
+  EnterMode: {
+    readonly targets: readonly CapturedTarget[];
+  };
+  ExitMode: {};
+  MoveSelection: {
+    readonly direction: "next" | "previous";
+  };
+  DeselectCurrent: {};
+  ToggleCurrent: {};
+  SelectAtCell: {
+    readonly x: number;
+    readonly y: number;
+  };
+  StartDraft: {};
+  CommitDraft: {
+    readonly body: string;
+  };
+  CancelDraft: {};
+}>;
+declare const CaptureModeIntent: {
+  readonly EnterMode: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "EnterMode";
+    readonly targets: readonly CapturedTarget[];
+  }, "_tag">;
+  readonly ExitMode: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "ExitMode";
+  }, "_tag">;
+  readonly MoveSelection: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "MoveSelection";
+    readonly direction: "next" | "previous";
+  }, "_tag">;
+  readonly DeselectCurrent: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "DeselectCurrent";
+  }, "_tag">;
+  readonly ToggleCurrent: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "ToggleCurrent";
+  }, "_tag">;
+  readonly SelectAtCell: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "SelectAtCell";
+    readonly x: number;
+    readonly y: number;
+  }, "_tag">;
+  readonly StartDraft: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "StartDraft";
+  }, "_tag">;
+  readonly CommitDraft: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "CommitDraft";
+    readonly body: string;
+  }, "_tag">;
+  readonly CancelDraft: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "CancelDraft";
+  }, "_tag">;
+  readonly $is: <Tag extends "EnterMode" | "ExitMode" | "MoveSelection" | "DeselectCurrent" | "ToggleCurrent" | "SelectAtCell" | "StartDraft" | "CommitDraft" | "CancelDraft">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "EnterMode";
+    readonly targets: readonly CapturedTarget[];
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "ExitMode";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "MoveSelection";
+    readonly direction: "next" | "previous";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "DeselectCurrent";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "ToggleCurrent";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "SelectAtCell";
+    readonly x: number;
+    readonly y: number;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "StartDraft";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "CommitDraft";
+    readonly body: string;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "CancelDraft";
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends {
+      readonly EnterMode: (args: {
+        readonly _tag: "EnterMode";
+        readonly targets: readonly CapturedTarget[];
+      }) => any;
+      readonly ExitMode: (args: {
+        readonly _tag: "ExitMode";
+      }) => any;
+      readonly MoveSelection: (args: {
+        readonly _tag: "MoveSelection";
+        readonly direction: "next" | "previous";
+      }) => any;
+      readonly DeselectCurrent: (args: {
+        readonly _tag: "DeselectCurrent";
+      }) => any;
+      readonly ToggleCurrent: (args: {
+        readonly _tag: "ToggleCurrent";
+      }) => any;
+      readonly SelectAtCell: (args: {
+        readonly _tag: "SelectAtCell";
+        readonly x: number;
+        readonly y: number;
+      }) => any;
+      readonly StartDraft: (args: {
+        readonly _tag: "StartDraft";
+      }) => any;
+      readonly CommitDraft: (args: {
+        readonly _tag: "CommitDraft";
+        readonly body: string;
+      }) => any;
+      readonly CancelDraft: (args: {
+        readonly _tag: "CancelDraft";
+      }) => any;
+    }>(cases: Cases): (value: {
+      readonly _tag: "EnterMode";
+      readonly targets: readonly CapturedTarget[];
+    } | {
+      readonly _tag: "ExitMode";
+    } | {
+      readonly _tag: "MoveSelection";
+      readonly direction: "next" | "previous";
+    } | {
+      readonly _tag: "DeselectCurrent";
+    } | {
+      readonly _tag: "ToggleCurrent";
+    } | {
+      readonly _tag: "SelectAtCell";
+      readonly x: number;
+      readonly y: number;
+    } | {
+      readonly _tag: "StartDraft";
+    } | {
+      readonly _tag: "CommitDraft";
+      readonly body: string;
+    } | {
+      readonly _tag: "CancelDraft";
+    }) => _$effect_Unify0.Unify<ReturnType<Cases["EnterMode" | "ExitMode" | "MoveSelection" | "DeselectCurrent" | "ToggleCurrent" | "SelectAtCell" | "StartDraft" | "CommitDraft" | "CancelDraft"]>>;
+    <Cases extends {
+      readonly EnterMode: (args: {
+        readonly _tag: "EnterMode";
+        readonly targets: readonly CapturedTarget[];
+      }) => any;
+      readonly ExitMode: (args: {
+        readonly _tag: "ExitMode";
+      }) => any;
+      readonly MoveSelection: (args: {
+        readonly _tag: "MoveSelection";
+        readonly direction: "next" | "previous";
+      }) => any;
+      readonly DeselectCurrent: (args: {
+        readonly _tag: "DeselectCurrent";
+      }) => any;
+      readonly ToggleCurrent: (args: {
+        readonly _tag: "ToggleCurrent";
+      }) => any;
+      readonly SelectAtCell: (args: {
+        readonly _tag: "SelectAtCell";
+        readonly x: number;
+        readonly y: number;
+      }) => any;
+      readonly StartDraft: (args: {
+        readonly _tag: "StartDraft";
+      }) => any;
+      readonly CommitDraft: (args: {
+        readonly _tag: "CommitDraft";
+        readonly body: string;
+      }) => any;
+      readonly CancelDraft: (args: {
+        readonly _tag: "CancelDraft";
+      }) => any;
+    }>(value: {
+      readonly _tag: "EnterMode";
+      readonly targets: readonly CapturedTarget[];
+    } | {
+      readonly _tag: "ExitMode";
+    } | {
+      readonly _tag: "MoveSelection";
+      readonly direction: "next" | "previous";
+    } | {
+      readonly _tag: "DeselectCurrent";
+    } | {
+      readonly _tag: "ToggleCurrent";
+    } | {
+      readonly _tag: "SelectAtCell";
+      readonly x: number;
+      readonly y: number;
+    } | {
+      readonly _tag: "StartDraft";
+    } | {
+      readonly _tag: "CommitDraft";
+      readonly body: string;
+    } | {
+      readonly _tag: "CancelDraft";
+    }, cases: Cases): _$effect_Unify0.Unify<ReturnType<Cases["EnterMode" | "ExitMode" | "MoveSelection" | "DeselectCurrent" | "ToggleCurrent" | "SelectAtCell" | "StartDraft" | "CommitDraft" | "CancelDraft"]>>;
+  };
+};
+declare function transition(state: CaptureModeState, intent: CaptureModeIntent): CaptureModeState;
+//#endregion
+//#region src/capture-mode/service.d.ts
+/**
+ * Reported by host adapters when forwarding a `CaptureModeDispatchResult.toPersist`
+ * Capture to its sink fails or when dispatch itself rejects the draft as invalid.
+ */
+type CaptureModeDispatchError = CaptureValidationError | CapturePersistenceError;
+interface CaptureModeDispatchResult {
+  readonly state: CaptureModeState;
+  readonly toPersist?: Capture;
+}
+declare const CapturePersistence_base: Context.ServiceClass<CapturePersistence, "anscribe/capture-mode/service/CapturePersistence", {
+  readonly createCapture: (capture: Capture) => Effect.Effect<void, CapturePersistenceError>;
+}>;
+declare class CapturePersistence extends CapturePersistence_base {}
+declare const CaptureHostFailureReporter_base: Context.ServiceClass<CaptureHostFailureReporter, "anscribe/capture-mode/service/CaptureHostFailureReporter", {
+  readonly report: (error: CaptureModeDispatchError) => Effect.Effect<void>;
+}>;
+/**
+ * Host adapters route `CaptureModeDispatchError` here so the failure surfaces
+ * as a structured log entry. The default reporter logs via `Effect.logError`;
+ * tests override with `Layer.succeed(CaptureHostFailureReporter, ...)`.
+ */
+declare class CaptureHostFailureReporter extends CaptureHostFailureReporter_base {
+  static readonly live: Layer.Layer<CaptureHostFailureReporter, never, never>;
+}
+declare const CaptureMode_base: Context.ServiceClass<CaptureMode, "anscribe/capture-mode/service/CaptureMode", {
+  readonly dispatch: (intent: CaptureModeIntent) => Effect.Effect<CaptureModeDispatchResult, CaptureValidationError>;
+  readonly current: () => Effect.Effect<CaptureModeState>;
+}>;
+declare class CaptureMode extends CaptureMode_base {
+  static readonly live: Layer.Layer<CaptureMode, never, never>;
+}
+//#endregion
+//#region src/capture-overlay.d.ts
+declare const ANSCRIBE_OVERLAY: unique symbol;
+declare function markAsOverlay<R extends object>(renderable: R): R;
+declare function isAnscribeOverlay(renderable: unknown): boolean;
+//#endregion
+//#region src/clipboard-format.d.ts
+declare function formatCaptureForClipboard(capture: Capture): string;
+//#endregion
+//#region src/sinks.d.ts
+/**
+ * A destination that committed Captures are written to.
+ *
+ * Host adapters (e.g. `installCapture` in `@anscribe/opentui`) always write
+ * every committed Capture to the system clipboard via OSC52 first, then fan
+ * out to any user-supplied sinks in order. A sink encapsulates whatever
+ * resources its writes need — the host calls `close()` on shutdown so the
+ * sink can release them.
+ *
+ * Sinks are constructed by factories exposed from the package that owns the
+ * destination — see `mcpSink()` from `@anscribe/mcp` for the canonical
+ * example. Authors of new sinks can implement this interface directly.
+ *
+ * Sink `write` is allowed to throw or reject; the host wraps the failure in
+ * a `CapturePersistenceError` tagged with the sink's `name` and routes it
+ * through `CaptureHostFailureReporter`. A failing sink does not roll back
+ * earlier sinks' writes or the clipboard handoff.
+ */
+interface CaptureSink {
+  /**
+   * Identifier surfaced in failure messages (e.g. `"anscribe-mcp"`). Should
+   * be stable across instances; the React adapter uses the name set to gate
+   * `useEffect` reinitialisation when sink instances change between renders.
+   */
+  readonly name: string;
+  /** Persist a Capture. Called once per committed Capture, in array order. */
+  readonly write: (capture: Capture) => Promise<void>;
+  /** Optional cleanup. Called by the host on `dispose()` / `close()`. */
+  readonly close?: () => Promise<void>;
+}
+//#endregion
+export { ANSCRIBE_OVERLAY, Capture, CaptureEnrichmentOutput, CaptureHostFailureReporter, CaptureId, CaptureInput, CaptureMetadata, CaptureMetadataEnricher, CaptureMetadataEnrichment, CaptureMode, CaptureModeDispatchError, CaptureModeDispatchResult, CaptureModeIntent, CaptureModeState, CapturePersistence, CapturePersistenceError, CaptureProjectResolutionError, CaptureSink, CaptureStatus, CaptureValidationError, CapturedTarget, CapturedTargetId, IsoTimestamp, type PickerState, ResolvedCaptureProject, SourceReference, TerminalCellBounds, captureStatusSchema, decodeAnscribeData, decodeAnscribeDataEffect, formatCaptureForClipboard, generateCaptureId, generateCapturedTargetId, initialState, isAnscribeOverlay, makeCapture, markAsOverlay, noCaptureEnrichment, parseIsoTimestampMillis, resolveCaptureProjectBoundary, resolveTargetAtCell, selectCurrentTarget, transition };

package/dist/index.mjs

@@ -0,0 +1,411 @@
+import { Clock, Context, Data, DateTime, Effect, FileSystem, Layer, Path, Schema, SubscriptionRef } from "effect";
+import { customAlphabet } from "nanoid";
+//#region src/schema.ts
+const CaptureId = Schema.String.pipe(Schema.brand("CaptureId"));
+const CapturedTargetId = Schema.String.pipe(Schema.brand("CapturedTargetId"));
+const generateNanoid = customAlphabet("0123456789abcdefghijklmnopqrstuvwxyz", 12);
+const generateCaptureId = Effect.sync(() => CaptureId.make(generateNanoid()));
+const generateCapturedTargetId = Effect.sync(() => CapturedTargetId.make(generateNanoid()));
+const isIsoTimestamp = Schema.makeFilter((value) => {
+	return /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(value) && parseIsoTimestampMillis(value) !== void 0 ? true : "Expected ISO timestamp";
+});
+function parseIsoTimestampMillis(value) {
+	const millis = Date.parse(value);
+	return Number.isFinite(millis) ? millis : void 0;
+}
+const IsoTimestamp = Schema.String.check(isIsoTimestamp).pipe(Schema.brand("IsoTimestamp"));
+var CaptureValidationError = class extends Schema.TaggedErrorClass()("CaptureValidationError", {
+	message: Schema.String,
+	cause: Schema.optionalKey(Schema.Unknown)
+}) {};
+var CapturePersistenceError = class extends Schema.TaggedErrorClass()("CapturePersistenceError", {
+	message: Schema.String,
+	cause: Schema.optionalKey(Schema.Unknown)
+}) {};
+var TerminalCellBounds = class extends Schema.Class("TerminalCellBounds")({
+	x: Schema.Finite,
+	y: Schema.Finite,
+	width: Schema.Finite,
+	height: Schema.Finite
+}) {};
+var SourceReference = class extends Schema.Class("SourceReference")({
+	file: Schema.optionalKey(Schema.String),
+	line: Schema.optionalKey(Schema.Finite),
+	column: Schema.optionalKey(Schema.Finite),
+	functionName: Schema.optionalKey(Schema.String),
+	componentName: Schema.optionalKey(Schema.String),
+	origin: Schema.optionalKey(Schema.String)
+}) {};
+var CaptureMetadata = class extends Schema.Class("CaptureMetadata")({
+	identifier: Schema.optionalKey(Schema.String),
+	componentName: Schema.optionalKey(Schema.String),
+	componentPath: Schema.optionalKey(Schema.String)
+}) {};
+const captureStatusSchema = Schema.Literals(["pending", "resolved"]);
+var CapturedTarget = class extends Schema.Class("CapturedTarget")({
+	id: CapturedTargetId,
+	type: Schema.String,
+	bounds: TerminalCellBounds,
+	ancestry: Schema.Array(Schema.String),
+	visibleContent: Schema.optionalKey(Schema.String),
+	metadata: Schema.optionalKey(CaptureMetadata),
+	sourceReferences: Schema.optionalKey(Schema.Array(SourceReference))
+}) {};
+var Capture = class extends Schema.Class("Capture")({
+	id: CaptureId,
+	status: captureStatusSchema,
+	createdAt: IsoTimestamp,
+	instruction: Schema.optionalKey(Schema.String),
+	targets: Schema.Array(CapturedTarget)
+}) {};
+const makeCapture = (input) => decodeAnscribeDataEffect(Capture, input);
+function decodeAnscribeData(schema, input) {
+	try {
+		return Schema.decodeUnknownSync(schema)(input);
+	} catch (cause) {
+		throw new CaptureValidationError({
+			message: "Invalid Anscribe data",
+			cause
+		});
+	}
+}
+const decodeAnscribeDataEffect = (schema, input) => Schema.decodeUnknownEffect(schema)(input).pipe(Effect.mapError((cause) => new CaptureValidationError({
+	message: "Invalid Anscribe data",
+	cause
+})));
+//#endregion
+//#region src/project.ts
+var CaptureProjectResolutionError = class extends Schema.TaggedErrorClass()("CaptureProjectResolutionError", {
+	message: Schema.String,
+	cause: Schema.optionalKey(Schema.Unknown)
+}) {};
+var ProjectMarkerNotFoundError = class extends Schema.TaggedErrorClass()("ProjectMarkerNotFoundError", {
+	cwd: Schema.String,
+	start: Schema.String
+}) {};
+var ProjectPathResolutionError = class extends Schema.TaggedErrorClass()("ProjectPathResolutionError", {
+	path: Schema.String,
+	cause: Schema.Unknown
+}) {};
+const workspaceMarkers = [
+	"pnpm-workspace.yaml",
+	"bun.lock",
+	"package-lock.json",
+	"yarn.lock",
+	"package.json"
+];
+const projectMarkerNames = [".git", ...workspaceMarkers];
+const resolveCaptureProjectBoundary = (cwd) => resolveCaptureProjectRoot(cwd).pipe(Effect.map((projectRoot) => ({ projectRoot })), Effect.mapError(toCaptureProjectResolutionError));
+const resolveCaptureProjectRoot = Effect.fn("Project.resolveCaptureProjectRoot")(function* (cwd) {
+	const fs = yield* FileSystem.FileSystem;
+	const start = yield* Effect.mapError(fs.realPath(cwd), (cause) => new ProjectPathResolutionError({
+		path: cwd,
+		cause
+	}));
+	const projectRoot = yield* findProjectRoot(start);
+	if (projectRoot === void 0) return yield* new ProjectMarkerNotFoundError({
+		cwd,
+		start
+	});
+	return projectRoot;
+});
+const findProjectRoot = Effect.fn("Project.findProjectRoot")(function* (start) {
+	const path = yield* Path.Path;
+	let current = start;
+	while (true) {
+		if (yield* hasProjectMarker(current)) return current;
+		const parent = path.dirname(current);
+		if (parent === current) return;
+		current = parent;
+	}
+});
+const hasProjectMarker = Effect.fn("Project.hasProjectMarker")(function* (directory) {
+	const path = yield* Path.Path;
+	if (yield* markerExists(path.join(directory, ".git"))) return true;
+	for (const marker of workspaceMarkers) if (yield* markerExists(path.join(directory, marker))) return true;
+	return false;
+});
+const markerExists = Effect.fn("Project.markerExists")(function* (path) {
+	const fs = yield* FileSystem.FileSystem;
+	return yield* Effect.mapError(fs.exists(path), (cause) => new ProjectPathResolutionError({
+		path,
+		cause
+	}));
+});
+function toCaptureProjectResolutionError(error) {
+	if (Schema.is(CaptureProjectResolutionError)(error)) return error;
+	if (Schema.is(ProjectMarkerNotFoundError)(error)) return new CaptureProjectResolutionError({
+		message: `No Anscribe project markers found from ${error.start}. Add a .git directory/file or package workspace marker (${projectMarkerNames.join(", ")}).`,
+		cause: error
+	});
+	if (Schema.is(ProjectPathResolutionError)(error)) return new CaptureProjectResolutionError({
+		message: `Unable to resolve Anscribe project path ${error.path}.`,
+		cause: error.cause
+	});
+	return new CaptureProjectResolutionError({
+		message: "Unable to resolve Anscribe project path.",
+		cause: error
+	});
+}
+//#endregion
+//#region src/enrichment.ts
+const noCaptureEnrichment = Effect.succeed(void 0);
+var CaptureMetadataEnrichment = class extends Context.Service()("anscribe/enrichment/CaptureMetadataEnrichment") {
+	static live = Layer.succeed(this, this.of({ enrich: () => noCaptureEnrichment }));
+	static layer = (enricher) => Layer.succeed(this, this.of({ enrich: enricher }));
+};
+//#endregion
+//#region src/picker/state.ts
+const PickerIntent = Data.taggedEnum();
+const PICKER_INTENT_TAGS = new Set([
+	"EnterMode",
+	"ExitMode",
+	"MoveSelection",
+	"DeselectCurrent",
+	"ToggleCurrent",
+	"SelectAtCell"
+]);
+function isPickerIntent(intent) {
+	return PICKER_INTENT_TAGS.has(intent._tag);
+}
+function pickerTransition(state, intent) {
+	return PickerIntent.$match(intent, {
+		EnterMode: ({ targets }) => ({
+			active: true,
+			targets,
+			currentIndex: -1,
+			selectedTargetIds: []
+		}),
+		ExitMode: () => ({
+			active: false,
+			targets: state.targets,
+			currentIndex: -1,
+			selectedTargetIds: []
+		}),
+		MoveSelection: ({ direction }) => {
+			if (!state.active || state.targets.length === 0) return state;
+			const length = state.targets.length;
+			const nextIndex = computeNextIndex(state.currentIndex, length, direction);
+			return {
+				...state,
+				currentIndex: nextIndex
+			};
+		},
+		DeselectCurrent: () => {
+			const currentTarget = selectCurrentTarget(state);
+			if (currentTarget === void 0) return state;
+			return {
+				...state,
+				selectedTargetIds: removeSelection(state.selectedTargetIds, currentTarget.id)
+			};
+		},
+		ToggleCurrent: () => {
+			const currentTarget = selectCurrentTarget(state);
+			if (currentTarget === void 0) return state;
+			return {
+				...state,
+				selectedTargetIds: state.selectedTargetIds.includes(currentTarget.id) ? removeSelection(state.selectedTargetIds, currentTarget.id) : addSelection(state.selectedTargetIds, currentTarget.id)
+			};
+		},
+		SelectAtCell: ({ x, y }) => {
+			if (!state.active) return state;
+			const target = resolveTargetAtCell(state.targets, x, y);
+			if (target === void 0) return state;
+			const nextIndex = state.targets.findIndex((candidate) => candidate.id === target.id);
+			return {
+				...state,
+				currentIndex: nextIndex,
+				selectedTargetIds: state.selectedTargetIds.includes(target.id) ? removeSelection(state.selectedTargetIds, target.id) : addSelection(state.selectedTargetIds, target.id)
+			};
+		}
+	});
+}
+function selectCurrentTarget(state) {
+	return state.active && state.currentIndex >= 0 ? state.targets[state.currentIndex] : void 0;
+}
+function selectSelectedTargets(state) {
+	if (state.selectedTargetIds.length > 0) return state.selectedTargetIds.map((id) => state.targets.find((target) => target.id === id)).filter((target) => target !== void 0);
+	const currentTarget = selectCurrentTarget(state);
+	return currentTarget !== void 0 ? [currentTarget] : [];
+}
+function resolveTargetAtCell(targets, x, y) {
+	return targets.filter((target) => containsCell(target.bounds, x, y)).toSorted((a, b) => b.ancestry.length - a.ancestry.length)[0];
+}
+function computeNextIndex(currentIndex, length, direction) {
+	if (currentIndex < 0) return direction === "next" ? 0 : length - 1;
+	return direction === "next" ? (currentIndex + 1) % length : (currentIndex - 1 + length) % length;
+}
+function containsCell(bounds, x, y) {
+	return x >= bounds.x && x < bounds.x + bounds.width && y >= bounds.y && y < bounds.y + bounds.height;
+}
+function addSelection(existing, id) {
+	return existing.includes(id) ? existing : [...existing, id];
+}
+function removeSelection(existing, id) {
+	const next = existing.filter((candidate) => candidate !== id);
+	return next.length === existing.length ? existing : next;
+}
+//#endregion
+//#region src/capture-mode/state.ts
+const initialState = {
+	active: false,
+	targets: [],
+	currentIndex: -1,
+	selectedTargetIds: [],
+	instructionDraft: false
+};
+const CaptureModeIntent = Data.taggedEnum();
+function transition(state, intent) {
+	if (isPickerIntent(intent)) {
+		const next = pickerTransition(state, intent);
+		if (intent._tag === "EnterMode" || intent._tag === "ExitMode") return {
+			...next,
+			instructionDraft: false
+		};
+		return next;
+	}
+	return draftTransition(state, intent);
+}
+function draftTransition(state, intent) {
+	switch (intent._tag) {
+		case "StartDraft":
+			if (selectCurrentTarget(state) === void 0 && state.selectedTargetIds.length === 0) return state;
+			return {
+				...state,
+				instructionDraft: true
+			};
+		case "CommitDraft": {
+			if (!state.instructionDraft) return state;
+			const hasExplicitSelection = state.selectedTargetIds.length > 0;
+			const willPersist = intent.body.trim().length > 0 && hasResolvedTargets(state);
+			return {
+				...state,
+				instructionDraft: false,
+				selectedTargetIds: willPersist && hasExplicitSelection ? [] : state.selectedTargetIds
+			};
+		}
+		case "CancelDraft":
+			if (!state.instructionDraft) return state;
+			return {
+				...state,
+				instructionDraft: false
+			};
+	}
+}
+function hasResolvedTargets(state) {
+	if (state.selectedTargetIds.length > 0) return true;
+	return selectCurrentTarget(state) !== void 0;
+}
+//#endregion
+//#region src/capture-mode/service.ts
+var CapturePersistence = class extends Context.Service()("anscribe/capture-mode/service/CapturePersistence") {};
+/**
+* Host adapters route `CaptureModeDispatchError` here so the failure surfaces
+* as a structured log entry. The default reporter logs via `Effect.logError`;
+* tests override with `Layer.succeed(CaptureHostFailureReporter, ...)`.
+*/
+var CaptureHostFailureReporter = class extends Context.Service()("anscribe/capture-mode/service/CaptureHostFailureReporter") {
+	static live = Layer.succeed(this, this.of({ report: Effect.fn("CaptureHostFailureReporter.report")((error) => Effect.logError("Unable to persist Anscribe Capture", error)) }));
+};
+var CaptureMode = class CaptureMode extends Context.Service()("anscribe/capture-mode/service/CaptureMode") {
+	static live = Layer.effect(CaptureMode, Effect.gen(function* () {
+		const ref = yield* SubscriptionRef.make(initialState);
+		return CaptureMode.of({
+			dispatch: Effect.fn("CaptureMode.dispatch")(function* (intent) {
+				if (intent._tag === "CommitDraft") {
+					const previousState = yield* SubscriptionRef.get(ref);
+					const state = yield* SubscriptionRef.updateAndGet(ref, (current) => transition(current, intent));
+					const toPersist = yield* makeCommitDraftCapture(previousState, intent.body);
+					return toPersist !== void 0 ? {
+						state,
+						toPersist
+					} : { state };
+				}
+				return { state: yield* SubscriptionRef.updateAndGet(ref, (current) => transition(current, intent)) };
+			}),
+			current: () => SubscriptionRef.get(ref)
+		});
+	}));
+};
+const makeCommitDraftCapture = (state, body) => Effect.gen(function* () {
+	const trimmedBody = body.trim();
+	if (!(!state.instructionDraft || trimmedBody.length > 0)) return;
+	const selectedTargets = selectSelectedTargets(state);
+	if (selectedTargets.length === 0) return;
+	const instruction = trimmedBody.length > 0 ? trimmedBody : void 0;
+	const millis = yield* Clock.currentTimeMillis;
+	const createdAt = DateTime.formatIso(DateTime.makeUnsafe(millis));
+	const targets = yield* Effect.forEach(selectedTargets, (target) => Effect.gen(function* () {
+		const id = yield* generateCapturedTargetId;
+		return yield* decodeAnscribeDataEffect(CapturedTarget, {
+			...target,
+			id
+		});
+	}));
+	return yield* makeCapture({
+		id: yield* generateCaptureId,
+		createdAt: IsoTimestamp.make(createdAt),
+		status: "pending",
+		...instruction !== void 0 && { instruction },
+		targets
+	});
+});
+//#endregion
+//#region src/capture-overlay.ts
+const ANSCRIBE_OVERLAY = Symbol.for("anscribe.captureOverlay");
+function markAsOverlay(renderable) {
+	Object.defineProperty(renderable, ANSCRIBE_OVERLAY, {
+		value: true,
+		enumerable: false,
+		configurable: false,
+		writable: false
+	});
+	return renderable;
+}
+function isAnscribeOverlay(renderable) {
+	return renderable !== null && typeof renderable === "object" && renderable[ANSCRIBE_OVERLAY] === true;
+}
+//#endregion
+//#region src/clipboard-format.ts
+const VISIBLE_CONTENT_PREVIEW_LIMIT = 200;
+function formatCaptureForClipboard(capture) {
+	const blocks = [];
+	if (capture.instruction !== void 0 && capture.instruction.length > 0) blocks.push(capture.instruction);
+	for (const target of capture.targets) blocks.push(formatTarget(target));
+	return blocks.join("\n\n");
+}
+function formatTarget(target) {
+	return [formatTargetHeader(target), ...formatTargetAncestry(target)].join("\n");
+}
+function formatTargetHeader(target) {
+	const identifier = target.metadata?.identifier;
+	const idAttr = identifier !== void 0 ? ` id="${identifier}"` : "";
+	const preview = formatVisibleContent(target.visibleContent);
+	const suffix = preview !== void 0 ? ` ${preview}` : "";
+	return `<${target.type}${idAttr}>${suffix}`;
+}
+function formatVisibleContent(content) {
+	if (content === void 0) return void 0;
+	const collapsed = content.replace(/\s+/g, " ").trim();
+	if (collapsed.length === 0) return void 0;
+	return `"${collapsed.length > VISIBLE_CONTENT_PREVIEW_LIMIT ? `${collapsed.slice(0, VISIBLE_CONTENT_PREVIEW_LIMIT - 1)}…` : collapsed}"`;
+}
+function formatTargetAncestry(target) {
+	const sourceReferences = target.sourceReferences ?? [];
+	if (sourceReferences.length > 0) return sourceReferences.map(formatSourceReferenceLine).filter((line) => line !== void 0);
+	const componentPath = target.metadata?.componentPath;
+	if (componentPath !== void 0 && componentPath.length > 0) return componentPath.split(" > ").map((name) => name.trim()).filter((name) => name.length > 0).map((name) => `  in ${name}`);
+	return [];
+}
+function formatSourceReferenceLine(reference) {
+	const name = reference.componentName ?? "<anonymous>";
+	const location = formatSourceLocation(reference.file, reference.line);
+	if (location === void 0 && reference.componentName === void 0) return;
+	return location !== void 0 ? `  in ${name} (at ${location})` : `  in ${name}`;
+}
+function formatSourceLocation(file, line) {
+	if (file === void 0) return void 0;
+	return line !== void 0 ? `${file}:${line}` : file;
+}
+//#endregion
+export { ANSCRIBE_OVERLAY, Capture, CaptureHostFailureReporter, CaptureId, CaptureMetadata, CaptureMetadataEnrichment, CaptureMode, CaptureModeIntent, CapturePersistence, CapturePersistenceError, CaptureProjectResolutionError, CaptureValidationError, CapturedTarget, CapturedTargetId, IsoTimestamp, SourceReference, TerminalCellBounds, captureStatusSchema, decodeAnscribeData, decodeAnscribeDataEffect, formatCaptureForClipboard, generateCaptureId, generateCapturedTargetId, initialState, isAnscribeOverlay, makeCapture, markAsOverlay, noCaptureEnrichment, parseIsoTimestampMillis, resolveCaptureProjectBoundary, resolveTargetAtCell, selectCurrentTarget, transition };

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@anscribe/core",
+  "version": "0.1.0",
+  "description": "Anscribe core: OpenTUI-agnostic capture model, project discovery, and clipboard formatting.",
+  "keywords": [
+    "agent",
+    "anscribe",
+    "capture",
+    "opentui",
+    "tui"
+  ],
+  "homepage": "https://github.com/msmps/anscribe",
+  "bugs": {
+    "url": "https://github.com/msmps/anscribe/issues"
+  },
+  "license": "MIT",
+  "author": "msmps",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/msmps/anscribe.git",
+    "directory": "packages/core"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true,
+    "registry": "https://registry.npmjs.org"
+  },
+  "dependencies": {
+    "effect": "^4.0.0-beta.65",
+    "nanoid": "^5.1.6"
+  },
+  "devDependencies": {
+    "@effect/platform-node": "^4.0.0-beta.65"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run"
+  }
+}