@smthrs/std 0.0.0-stage → 1.0.0-rc.12

package/dist/cjs/internal/ApplyPatch.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/ApplyPatch.ts"],
+  "sourcesContent": ["/**\n * Faithful port of the Codex CLI apply_patch engine.\n *\n * Mirrors `codex-rs/apply-patch/src/{parser,streaming_parser,seek_sequence}.rs`\n * and the applier in `lib.rs`: the V4A patch grammar, the lenient heredoc\n * boundary handling, the fuzzy context-matching ladder, and every error\n * string, so ChatGPT-family models see exactly the behavior they were\n * posttrained on. Pure module: no host access.\n *\n * @since 1.0.0\n */\n\nimport * as Schema from \"effect/Schema\"\nimport { sourceLines } from \"./Text.ts\"\n\nconst BEGIN_PATCH_MARKER = \"*** Begin Patch\"\nconst END_PATCH_MARKER = \"*** End Patch\"\nconst ADD_FILE_MARKER = \"*** Add File: \"\nconst DELETE_FILE_MARKER = \"*** Delete File: \"\nconst UPDATE_FILE_MARKER = \"*** Update File: \"\nconst MOVE_TO_MARKER = \"*** Move to: \"\nconst EOF_MARKER = \"*** End of File\"\nconst CHANGE_CONTEXT_MARKER = \"@@ \"\nconst EMPTY_CHANGE_CONTEXT_MARKER = \"@@\"\nconst ENVIRONMENT_ID_MARKER = \"*** Environment ID:\"\n\n/**\n * Parse failure with Codex-identical message text.\n *\n * `invalid patch: {message}` for patch-level failures and\n * `invalid hunk at line {line}, {message}` for hunk-level failures.\n *\n * @since 1.0.0\n * @private\n */\nexport class ParseError extends Schema.TaggedError<ParseError>()(\"@smthrs/std/ParseError\", {\n  kind: Schema.Literals([\"invalid_patch\", \"invalid_hunk\"]),\n  detail: Schema.String,\n  lineNumber: Schema.UndefinedOr(Schema.Number)\n}) {\n  override get message(): string {\n    return this.kind === \"invalid_patch\"\n      ? `invalid patch: ${this.detail}`\n      : `invalid hunk at line ${this.lineNumber}, ${this.detail}`\n  }\n}\n\nconst parseError = (kind: ParseError[\"kind\"], detail: string, lineNumber?: number): ParseError =>\n  new ParseError({ kind, detail, lineNumber })\n\n/**\n * One replaced region of an update hunk.\n *\n * @since 1.0.0\n * @private\n */\nexport interface UpdateFileChunk {\n  changeContext: string | undefined\n  oldLines: Array<string>\n  newLines: Array<string>\n  isEndOfFile: boolean\n}\n\n/**\n * A parsed patch hunk.\n *\n * @since 1.0.0\n * @private\n */\nexport type Hunk =\n  | { readonly kind: \"add\"; readonly path: string; contents: string }\n  | { readonly kind: \"delete\"; readonly path: string }\n  | {\n    readonly kind: \"update\"\n    readonly path: string\n    movePath: string | undefined\n    readonly chunks: Array<UpdateFileChunk>\n  }\n\n/**\n * Parsed patch: hunks plus the optional environment id preamble.\n *\n * @since 1.0.0\n * @private\n */\nexport interface ParsedPatch {\n  readonly hunks: ReadonlyArray<Hunk>\n  readonly environmentId: string | undefined\n}\n\ntype Mode =\n  | { readonly _tag: \"NotStarted\" }\n  | { readonly _tag: \"StartedPatch\" }\n  | { readonly _tag: \"AddFile\" }\n  | { readonly _tag: \"DeleteFile\" }\n  | { readonly _tag: \"UpdateFile\"; readonly hunkLineNumber: number; readonly hunk: Extract<Hunk, { kind: \"update\" }> }\n  | { readonly _tag: \"EndedPatch\" }\n\nconst invalidHunkHeader = (trimmed: string, lineNumber: number): ParseError =>\n  parseError(\n    \"invalid_hunk\",\n    `'${trimmed}' is not a valid hunk header. Valid hunk headers: '*** Add File: {path}', '*** Delete File: {path}', '*** Update File: {path}'`,\n    lineNumber\n  )\n\nconst unexpectedUpdateLine = (line: string, lineNumber: number): ParseError =>\n  parseError(\n    \"invalid_hunk\",\n    `Unexpected line found in update hunk: '${line}'. Every line should start with ' ' (context line), '+' (added line), or '-' (removed line)`,\n    lineNumber\n  )\n\n/**\n * Streaming line state machine for the V4A patch grammar; a faithful port of\n * `StreamingPatchParser`.\n *\n * @since 1.0.0\n * @private\n */\nexport class StreamingPatchParser {\n  private lineBuffer = \"\"\n  private mode: Mode = { _tag: \"NotStarted\" }\n  private hunks: Array<Hunk> = []\n  private lineNumber = 0\n  private _environmentId: string | undefined\n\n  environmentId(): string | undefined {\n    return this._environmentId\n  }\n\n  private ensureUpdateHunkIsNotEmpty(line: string): void {\n    const last = this.hunks[this.hunks.length - 1]\n    if (last === undefined || last.kind !== \"update\") return\n    if (last.chunks.length === 0 && this.mode._tag === \"UpdateFile\") {\n      throw parseError(\n        \"invalid_hunk\",\n        `Update file hunk for path '${last.path}' is empty`,\n        this.mode.hunkLineNumber\n      )\n    }\n    const chunk = last.chunks[last.chunks.length - 1]\n    if (chunk !== undefined && chunk.oldLines.length === 0 && chunk.newLines.length === 0) {\n      if (line === END_PATCH_MARKER) {\n        throw parseError(\"invalid_hunk\", \"Update hunk does not contain any lines\", this.lineNumber)\n      }\n      throw unexpectedUpdateLine(line, this.lineNumber)\n    }\n  }\n\n  private handleHunkHeadersAndEndPatch(trimmed: string): boolean {\n    if (this.mode._tag === \"StartedPatch\" && trimmed.startsWith(ENVIRONMENT_ID_MARKER)) {\n      if (this._environmentId !== undefined) {\n        throw parseError(\"invalid_patch\", \"apply_patch environment_id cannot be specified more than once\")\n      }\n      const environmentId = trimmed.slice(ENVIRONMENT_ID_MARKER.length).trim()\n      if (environmentId === \"\") {\n        throw parseError(\"invalid_patch\", \"apply_patch environment_id cannot be empty\")\n      }\n      this._environmentId = environmentId\n      return true\n    }\n    if (trimmed === END_PATCH_MARKER) {\n      this.ensureUpdateHunkIsNotEmpty(trimmed)\n      this.mode = { _tag: \"EndedPatch\" }\n      return true\n    }\n    if (trimmed.startsWith(ADD_FILE_MARKER)) {\n      this.ensureUpdateHunkIsNotEmpty(trimmed)\n      this.hunks.push({ kind: \"add\", path: trimmed.slice(ADD_FILE_MARKER.length), contents: \"\" })\n      this.mode = { _tag: \"AddFile\" }\n      return true\n    }\n    if (trimmed.startsWith(DELETE_FILE_MARKER)) {\n      this.ensureUpdateHunkIsNotEmpty(trimmed)\n      this.hunks.push({ kind: \"delete\", path: trimmed.slice(DELETE_FILE_MARKER.length) })\n      this.mode = { _tag: \"DeleteFile\" }\n      return true\n    }\n    if (trimmed.startsWith(UPDATE_FILE_MARKER)) {\n      this.ensureUpdateHunkIsNotEmpty(trimmed)\n      const hunk: Extract<Hunk, { kind: \"update\" }> = {\n        kind: \"update\",\n        path: trimmed.slice(UPDATE_FILE_MARKER.length),\n        movePath: undefined,\n        chunks: []\n      }\n      this.hunks.push(hunk)\n      this.mode = { _tag: \"UpdateFile\", hunkLineNumber: this.lineNumber, hunk }\n      return true\n    }\n    return false\n  }\n\n  pushDelta(delta: string): ReadonlyArray<Hunk> {\n    for (const ch of delta) {\n      if (ch === \"\\n\") {\n        let line = this.lineBuffer\n        this.lineBuffer = \"\"\n        if (line.endsWith(\"\\r\")) line = line.slice(0, -1)\n        this.lineNumber += 1\n        this.processLine(line)\n      } else {\n        this.lineBuffer += ch\n      }\n    }\n    return this.hunks\n  }\n\n  finish(): ReadonlyArray<Hunk> {\n    if (this.lineBuffer !== \"\") {\n      const line = this.lineBuffer\n      this.lineBuffer = \"\"\n      this.lineNumber += 1\n      if (line.trim() === END_PATCH_MARKER) {\n        this.ensureUpdateHunkIsNotEmpty(line.trim())\n        this.mode = { _tag: \"EndedPatch\" }\n      } else {\n        this.processLine(line)\n      }\n    }\n    if (this.mode._tag !== \"EndedPatch\") {\n      throw parseError(\"invalid_patch\", \"The last line of the patch must be '*** End Patch'\")\n    }\n    return this.hunks\n  }\n\n  private processLine(line: string): void {\n    const trimmed = line.trim()\n    switch (this.mode._tag) {\n      case \"NotStarted\": {\n        if (trimmed === BEGIN_PATCH_MARKER) {\n          this.mode = { _tag: \"StartedPatch\" }\n          return\n        }\n        throw parseError(\"invalid_patch\", \"The first line of the patch must be '*** Begin Patch'\")\n      }\n      case \"StartedPatch\": {\n        if (this.handleHunkHeadersAndEndPatch(trimmed)) return\n        throw invalidHunkHeader(trimmed, this.lineNumber)\n      }\n      case \"AddFile\": {\n        if (this.handleHunkHeadersAndEndPatch(trimmed)) return\n        const last = this.hunks[this.hunks.length - 1]\n        if (line.startsWith(\"+\") && last !== undefined && last.kind === \"add\") {\n          last.contents += `${line.slice(1)}\\n`\n          return\n        }\n        throw invalidHunkHeader(trimmed, this.lineNumber)\n      }\n      case \"DeleteFile\": {\n        if (this.handleHunkHeadersAndEndPatch(trimmed)) return\n        throw invalidHunkHeader(trimmed, this.lineNumber)\n      }\n      case \"UpdateFile\": {\n        const updateLine = line.replace(/\\s+$/, \"\")\n        if (this.handleHunkHeadersAndEndPatch(updateLine)) return\n\n        const hunk = this.mode.hunk\n        const chunks = hunk.chunks\n        const lastChunk = chunks[chunks.length - 1]\n        if (lastChunk !== undefined && lastChunk.isEndOfFile) {\n          if (updateLine === \"\") return\n          if (updateLine !== EMPTY_CHANGE_CONTEXT_MARKER && !updateLine.startsWith(CHANGE_CONTEXT_MARKER)) {\n            throw parseError(\n              \"invalid_hunk\",\n              `Expected update hunk to start with a @@ context marker, got: '${line}'`,\n              this.lineNumber\n            )\n          }\n        }\n\n        if (chunks.length === 0 && hunk.movePath === undefined && updateLine.startsWith(MOVE_TO_MARKER)) {\n          hunk.movePath = updateLine.slice(MOVE_TO_MARKER.length)\n          return\n        }\n\n        if (\n          (updateLine === EMPTY_CHANGE_CONTEXT_MARKER || updateLine.startsWith(CHANGE_CONTEXT_MARKER)) &&\n          lastChunk !== undefined && lastChunk.oldLines.length === 0 && lastChunk.newLines.length === 0\n        ) {\n          throw unexpectedUpdateLine(line, this.lineNumber)\n        }\n\n        if (updateLine === EMPTY_CHANGE_CONTEXT_MARKER) {\n          chunks.push({ changeContext: undefined, oldLines: [], newLines: [], isEndOfFile: false })\n          return\n        }\n\n        if (updateLine.startsWith(CHANGE_CONTEXT_MARKER)) {\n          chunks.push({\n            changeContext: updateLine.slice(CHANGE_CONTEXT_MARKER.length),\n            oldLines: [],\n            newLines: [],\n            isEndOfFile: false\n          })\n          return\n        }\n\n        if (updateLine === EOF_MARKER) {\n          if (lastChunk !== undefined && lastChunk.oldLines.length === 0 && lastChunk.newLines.length === 0) {\n            throw parseError(\"invalid_hunk\", \"Update hunk does not contain any lines\", this.lineNumber)\n          }\n          if (lastChunk !== undefined) lastChunk.isEndOfFile = true\n          return\n        }\n\n        const ensureChunk = (): UpdateFileChunk => {\n          if (chunks.length === 0) {\n            chunks.push({ changeContext: undefined, oldLines: [], newLines: [], isEndOfFile: false })\n          }\n          return chunks[chunks.length - 1]!\n        }\n\n        if (line === \"\") {\n          const chunk = ensureChunk()\n          chunk.oldLines.push(\"\")\n          chunk.newLines.push(\"\")\n          return\n        }\n        if (line.startsWith(\" \")) {\n          const chunk = ensureChunk()\n          chunk.oldLines.push(line.slice(1))\n          chunk.newLines.push(line.slice(1))\n          return\n        }\n        if (line.startsWith(\"+\")) {\n          ensureChunk().newLines.push(line.slice(1))\n          return\n        }\n        if (line.startsWith(\"-\")) {\n          ensureChunk().oldLines.push(line.slice(1))\n          return\n        }\n        if (lastChunk !== undefined && (lastChunk.oldLines.length > 0 || lastChunk.newLines.length > 0)) {\n          throw parseError(\n            \"invalid_hunk\",\n            `Expected update hunk to start with a @@ context marker, got: '${line}'`,\n            this.lineNumber\n          )\n        }\n        throw unexpectedUpdateLine(line, this.lineNumber)\n      }\n      case \"EndedPatch\": {\n        if (trimmed === \"\") return\n        throw parseError(\"invalid_patch\", \"The last line of the patch must be '*** End Patch'\")\n      }\n    }\n  }\n}\n\nconst checkStartAndEndLinesStrict = (firstLine: string | undefined, lastLine: string | undefined): void => {\n  const first = firstLine?.trim()\n  const last = lastLine?.trim()\n  if (first === BEGIN_PATCH_MARKER && last === END_PATCH_MARKER) return\n  if (first !== undefined && first !== BEGIN_PATCH_MARKER) {\n    throw parseError(\"invalid_patch\", \"The first line of the patch must be '*** Begin Patch'\")\n  }\n  throw parseError(\"invalid_patch\", \"The last line of the patch must be '*** End Patch'\")\n}\n\nconst checkPatchBoundariesStrict = (lines: ReadonlyArray<string>): ReadonlyArray<string> => {\n  checkStartAndEndLinesStrict(lines[0], lines.length === 0 ? undefined : lines[lines.length - 1])\n  return lines\n}\n\nconst checkPatchBoundariesLenient = (originalLines: ReadonlyArray<string>): ReadonlyArray<string> => {\n  let originalError: ParseError\n  try {\n    return checkPatchBoundariesStrict(originalLines)\n  } catch (error) {\n    originalError = error as ParseError\n  }\n  if (originalLines.length >= 2) {\n    const first = originalLines[0]!\n    const last = originalLines[originalLines.length - 1]!\n    if (\n      (first === \"<<EOF\" || first === \"<<'EOF'\" || first === \"<<\\\"EOF\\\"\") &&\n      last.endsWith(\"EOF\") && originalLines.length >= 4\n    ) {\n      return checkPatchBoundariesStrict(originalLines.slice(1, -1))\n    }\n  }\n  throw originalError\n}\n\n/**\n * Parse a complete patch text; lenient mode (heredoc unwrapping) is always\n * on, matching Codex.\n *\n * @since 1.0.0\n * @private\n */\nexport const parsePatch = (patch: string): ParsedPatch => {\n  const trimmed = patch.trim()\n  const lines = trimmed === \"\" ? [] : trimmed.split(\"\\n\")\n  const patchLines = checkPatchBoundariesLenient(lines)\n  const parser = new StreamingPatchParser()\n  parser.pushDelta(`${patchLines.join(\"\\n\")}\\n`)\n  const hunks = parser.finish()\n  return { hunks, environmentId: parser.environmentId() }\n}\n\nconst normalise = (s: string): string =>\n  [...s.trim()].map((c) => {\n    switch (c) {\n      case \"\u2010\":\n      case \"\u2011\":\n      case \"\u2012\":\n      case \"\u2013\":\n      case \"\u2014\":\n      case \"\u2015\":\n      case \"\u2212\":\n        return \"-\"\n      case \"\u2018\":\n      case \"\u2019\":\n      case \"\u201A\":\n      case \"\u201B\":\n        return \"'\"\n      case \"\u201C\":\n      case \"\u201D\":\n      case \"\u201E\":\n      case \"\u201F\":\n        return \"\\\"\"\n      case \"\u00A0\":\n      case \"\u2002\":\n      case \"\u2003\":\n      case \"\u2004\":\n      case \"\u2005\":\n      case \"\u2006\":\n      case \"\u2007\":\n      case \"\u2008\":\n      case \"\u2009\":\n      case \"\u200A\":\n      case \"\u202F\":\n      case \"\u205F\":\n      case \"\u3000\":\n        return \" \"\n      default:\n        return c\n    }\n  }).join(\"\")\n\n/**\n * Fuzzy sequence search with the Codex leniency ladder: exact, rstrip, trim,\n * then unicode-normalised comparison; end-of-file patterns anchor at the end\n * first.\n *\n * @since 1.0.0\n * @private\n */\nexport const seekSequence = (\n  lines: ReadonlyArray<string>,\n  pattern: ReadonlyArray<string>,\n  start: number,\n  eof: boolean\n): number | undefined => {\n  if (pattern.length === 0) return start\n  if (pattern.length > lines.length) return undefined\n  const searchStart = eof && lines.length >= pattern.length ? lines.length - pattern.length : start\n  const upper = lines.length - pattern.length\n  const passes: ReadonlyArray<(a: string, b: string) => boolean> = [\n    (a, b) => a === b,\n    (a, b) => a.replace(/\\s+$/, \"\") === b.replace(/\\s+$/, \"\"),\n    (a, b) => a.trim() === b.trim(),\n    (a, b) => normalise(a) === normalise(b)\n  ]\n  for (const equals of passes) {\n    for (let i = searchStart; i <= upper; i++) {\n      let ok = true\n      for (let p = 0; p < pattern.length; p++) {\n        if (!equals(lines[i + p]!, pattern[p]!)) {\n          ok = false\n          break\n        }\n      }\n      if (ok) return i\n    }\n  }\n  return undefined\n}\n\n/**\n * Applier failure carrying the Codex message text verbatim.\n *\n * `context_not_found` is an `@@` context line absent from the file;\n * `lines_not_found` is a chunk whose expected lines are absent.\n *\n * @since 1.0.0\n * @private\n */\nexport class ComputeReplacementsError extends Schema.TaggedError<ComputeReplacementsError>()(\n  \"@smthrs/std/ComputeReplacementsError\",\n  {\n    reason: Schema.Literals([\"context_not_found\", \"lines_not_found\"]),\n    path: Schema.String,\n    message: Schema.String\n  }\n) {}\n\ntype Replacement = readonly [startIndex: number, oldLength: number, newLines: ReadonlyArray<string>]\n\nconst computeReplacements = (\n  originalLines: ReadonlyArray<string>,\n  path: string,\n  chunks: ReadonlyArray<UpdateFileChunk>\n): Array<Replacement> => {\n  const replacements: Array<Replacement> = []\n  let lineIndex = 0\n\n  for (const chunk of chunks) {\n    if (chunk.changeContext !== undefined) {\n      const idx = seekSequence(originalLines, [chunk.changeContext], lineIndex, false)\n      if (idx === undefined) {\n        throw new ComputeReplacementsError({\n          reason: \"context_not_found\",\n          path,\n          message: `Failed to find context '${chunk.changeContext}' in ${path}`\n        })\n      }\n      lineIndex = idx + 1\n    }\n\n    if (chunk.oldLines.length === 0) {\n      const insertionIdx = originalLines.length > 0 && originalLines[originalLines.length - 1] === \"\"\n        ? originalLines.length - 1\n        : originalLines.length\n      replacements.push([insertionIdx, 0, [...chunk.newLines]])\n      continue\n    }\n\n    let pattern: ReadonlyArray<string> = chunk.oldLines\n    let newSlice: ReadonlyArray<string> = chunk.newLines\n    let found = seekSequence(originalLines, pattern, lineIndex, chunk.isEndOfFile)\n\n    if (found === undefined && pattern[pattern.length - 1] === \"\") {\n      pattern = pattern.slice(0, -1)\n      if (newSlice[newSlice.length - 1] === \"\") newSlice = newSlice.slice(0, -1)\n      found = seekSequence(originalLines, pattern, lineIndex, chunk.isEndOfFile)\n    }\n\n    if (found !== undefined) {\n      replacements.push([found, pattern.length, [...newSlice]])\n      lineIndex = found + pattern.length\n    } else {\n      throw new ComputeReplacementsError({\n        reason: \"lines_not_found\",\n        path,\n        message: `Failed to find expected lines in ${path}:\\n${chunk.oldLines.join(\"\\n\")}`\n      })\n    }\n  }\n\n  replacements.sort((a, b) => a[0] - b[0])\n  return replacements\n}\n\nconst applyReplacements = (lines: Array<string>, replacements: ReadonlyArray<Replacement>): Array<string> => {\n  for (let r = replacements.length - 1; r >= 0; r--) {\n    const [startIdx, oldLength, newSegment] = replacements[r]!\n    lines.splice(startIdx, Math.min(oldLength, Math.max(lines.length - startIdx, 0)), ...newSegment)\n  }\n  return lines\n}\n\n/**\n * Derive the new file contents for an update hunk from the original\n * contents, matching Codex `derive_new_contents_from_chunks`.\n *\n * @since 1.0.0\n * @private\n */\nexport const deriveNewContents = (\n  originalContents: string,\n  path: string,\n  chunks: ReadonlyArray<UpdateFileChunk>\n): string => {\n  const originalLines = sourceLines(originalContents)\n  const replacements = computeReplacements(originalLines, path, chunks)\n  const newLines = applyReplacements([...originalLines], replacements)\n  if (newLines[newLines.length - 1] !== \"\") newLines.push(\"\")\n  return newLines.join(\"\\n\")\n}\n\n/**\n * Render the Codex success summary: `Success. Updated the following files:`\n * with `A`/`M`/`D` lines for adds, updates, and deletes in that order.\n *\n * @since 1.0.0\n * @private\n */\nexport const printSummary = (affected: {\n  readonly added: ReadonlyArray<string>\n  readonly modified: ReadonlyArray<string>\n  readonly deleted: ReadonlyArray<string>\n}): string => {\n  const lines = [\"Success. Updated the following files:\"]\n  for (const path of affected.added) lines.push(`A ${path}`)\n  for (const path of affected.modified) lines.push(`M ${path}`)\n  for (const path of affected.deleted) lines.push(`D ${path}`)\n  return `${lines.join(\"\\n\")}\\n`\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/internal/CodexText.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Faithful port of Codex CLI output truncation.
+ *
+ * Mirrors `codex-rs/utils/string/src/truncate.rs` and
+ * `codex-rs/utils/output-truncation/src/lib.rs`: middle truncation on UTF-8
+ * boundaries with a `…{n} tokens truncated…` marker and a 4-bytes-per-token
+ * estimate, so ChatGPT-family models see the exact shapes they were
+ * posttrained on.
+ *
+ * @since 1.0.0
+ */
+/**
+ * UTF-8 byte length of a string.
+ *
+ * @since 1.0.0
+ * @private
+ */
+export declare const byteLength: (text: string) => number;
+/**
+ * Approximate token count: ceil(utf8Bytes / 4).
+ *
+ * @since 1.0.0
+ * @private
+ */
+export declare const approxTokenCount: (text: string) => number;
+/**
+ * Approximate byte budget for a token budget.
+ *
+ * @since 1.0.0
+ * @private
+ */
+export declare const approxBytesForTokens: (tokens: number) => number;
+/**
+ * Approximate tokens represented by a byte count: ceil(bytes / 4).
+ *
+ * @since 1.0.0
+ * @private
+ */
+export declare const approxTokensFromByteCount: (bytes: number) => number;
+/**
+ * Middle-truncate to a byte budget with a char-count marker.
+ *
+ * @since 1.0.0
+ * @private
+ */
+export declare const truncateMiddleChars: (s: string, maxBytes: number) => string;
+/**
+ * Middle-truncate to an approximate token budget, preserving the beginning
+ * and end. Returns the possibly truncated string and the original token
+ * count when truncation occurred.
+ *
+ * @since 1.0.0
+ * @private
+ */
+export declare const truncateMiddleWithTokenBudget: (s: string, maxTokens: number) => {
+    readonly text: string;
+    readonly originalTokenCount: number | undefined;
+};
+/**
+ * Codex `format_exec_output_for_model`: exit code, wall time, optional line
+ * count disclosure, then the (possibly middle-truncated) output.
+ *
+ * @since 1.0.0
+ * @private
+ */
+export declare const formatExecOutputForModel: (options: {
+    readonly output: string;
+    readonly exitCode: number;
+    readonly durationSeconds: number;
+    readonly maxOutputTokens: number;
+    readonly timedOutAfterMs?: number | undefined;
+}) => string;
+//# sourceMappingURL=CodexText.d.ts.map

package/dist/cjs/internal/CodexText.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CodexText.d.ts","sourceRoot":"","sources":["../../../src/internal/CodexText.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAOH;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,MAAM,MAAM,KAAG,MAAyC,CAAA;AAEnF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,GAAI,MAAM,MAAM,KAAG,MACsC,CAAA;AAEtF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAAI,QAAQ,MAAM,KAAG,MAAyC,CAAA;AAE/F;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,GAAI,OAAO,MAAM,KAAG,MACiB,CAAA;AAqE3E;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAAI,GAAG,MAAM,EAAE,UAAU,MAAM,KAAG,MAAsD,CAAA;AAExH;;;;;;;GAOG;AACH,eAAO,MAAM,6BAA6B,GACxC,GAAG,MAAM,EACT,WAAW,MAAM,KAChB;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,GAAG,SAAS,CAAA;CAQ1E,CAAA;AAQD;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,GAAI,SAAS;IAChD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;IAChC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;IAChC,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAC9C,KAAG,MAeH,CAAA"}

package/dist/cjs/internal/CodexText.js

@@ -0,0 +1,108 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var CodexText_exports = {};
+__export(CodexText_exports, {
+  approxBytesForTokens: () => approxBytesForTokens,
+  approxTokenCount: () => approxTokenCount,
+  approxTokensFromByteCount: () => approxTokensFromByteCount,
+  byteLength: () => byteLength,
+  formatExecOutputForModel: () => formatExecOutputForModel,
+  truncateMiddleChars: () => truncateMiddleChars,
+  truncateMiddleWithTokenBudget: () => truncateMiddleWithTokenBudget
+});
+module.exports = __toCommonJS(CodexText_exports);
+const APPROX_BYTES_PER_TOKEN = 4;
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+const byteLength = (text) => encoder.encode(text).byteLength;
+const approxTokenCount = (text) => Math.floor((byteLength(text) + APPROX_BYTES_PER_TOKEN - 1) / APPROX_BYTES_PER_TOKEN);
+const approxBytesForTokens = (tokens) => tokens * APPROX_BYTES_PER_TOKEN;
+const approxTokensFromByteCount = (bytes) => Math.floor((bytes + APPROX_BYTES_PER_TOKEN - 1) / APPROX_BYTES_PER_TOKEN);
+const formatTruncationMarker = (useTokens, removedCount) => useTokens ? `\u2026${removedCount} tokens truncated\u2026` : `\u2026${removedCount} chars truncated\u2026`;
+const isContinuation = (byte) => (byte & 192) === 128;
+const boundaryAtOrBefore = (bytes, offset) => {
+  let at = Math.min(offset, bytes.byteLength);
+  while (at > 0 && at < bytes.byteLength && isContinuation(bytes[at])) at--;
+  return at;
+};
+const boundaryAtOrAfter = (bytes, offset) => {
+  let at = Math.max(offset, 0);
+  while (at < bytes.byteLength && isContinuation(bytes[at])) at++;
+  return at;
+};
+const splitString = (s, beginningBytes, endBytes) => {
+  const bytes = encoder.encode(s);
+  const tailStartTarget = Math.max(bytes.byteLength - endBytes, 0);
+  const prefixEnd = boundaryAtOrBefore(bytes, beginningBytes);
+  const suffixStart = boundaryAtOrAfter(bytes, Math.max(tailStartTarget, prefixEnd));
+  let removedChars = 0;
+  for (let at = prefixEnd; at < suffixStart; at++) if (!isContinuation(bytes[at])) removedChars++;
+  return {
+    removedChars,
+    before: decoder.decode(bytes.subarray(0, prefixEnd)),
+    after: decoder.decode(bytes.subarray(suffixStart))
+  };
+};
+const truncateWithByteEstimate = (s, maxBytes, useTokens) => {
+  if (s === "") return "";
+  const totalBytes = byteLength(s);
+  if (maxBytes === 0) {
+    return formatTruncationMarker(useTokens, useTokens ? approxTokensFromByteCount(totalBytes) : [...s].length);
+  }
+  if (totalBytes <= maxBytes) return s;
+  const leftBudget = Math.floor(maxBytes / 2);
+  const rightBudget = maxBytes - leftBudget;
+  const { after, before, removedChars } = splitString(s, leftBudget, rightBudget);
+  const marker = formatTruncationMarker(
+    useTokens,
+    useTokens ? approxTokensFromByteCount(Math.max(totalBytes - maxBytes, 0)) : removedChars
+  );
+  return `${before}${marker}${after}`;
+};
+const truncateMiddleChars = (s, maxBytes) => truncateWithByteEstimate(s, maxBytes, false);
+const truncateMiddleWithTokenBudget = (s, maxTokens) => {
+  if (s === "") return { text: "", originalTokenCount: void 0 };
+  if (maxTokens > 0 && byteLength(s) <= approxBytesForTokens(maxTokens)) {
+    return { text: s, originalTokenCount: void 0 };
+  }
+  const truncated = truncateWithByteEstimate(s, approxBytesForTokens(maxTokens), true);
+  if (truncated === s) return { text: s, originalTokenCount: void 0 };
+  return { text: truncated, originalTokenCount: approxTokenCount(s) };
+};
+const countLines = (content) => {
+  if (content === "") return 0;
+  const parts = content.split("\n");
+  return parts[parts.length - 1] === "" ? parts.length - 1 : parts.length;
+};
+const formatExecOutputForModel = (options) => {
+  const content = options.timedOutAfterMs === void 0 ? options.output : `command timed out after ${options.timedOutAfterMs} milliseconds
+${options.output}`;
+  const durationSeconds = Math.round(options.durationSeconds * 10) / 10;
+  const totalLines = countLines(content);
+  const formatted = truncateMiddleWithTokenBudget(content, options.maxOutputTokens).text;
+  const sections = [
+    `Exit code: ${options.exitCode}`,
+    `Wall time: ${durationSeconds} seconds`
+  ];
+  if (totalLines !== countLines(formatted)) sections.push(`Total output lines: ${totalLines}`);
+  sections.push("Output:");
+  sections.push(formatted);
+  return sections.join("\n");
+};
+//# sourceMappingURL=CodexText.js.map

package/dist/cjs/internal/CodexText.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/CodexText.ts"],
+  "sourcesContent": ["/**\n * Faithful port of Codex CLI output truncation.\n *\n * Mirrors `codex-rs/utils/string/src/truncate.rs` and\n * `codex-rs/utils/output-truncation/src/lib.rs`: middle truncation on UTF-8\n * boundaries with a `\u2026{n} tokens truncated\u2026` marker and a 4-bytes-per-token\n * estimate, so ChatGPT-family models see the exact shapes they were\n * posttrained on.\n *\n * @since 1.0.0\n */\n\nconst APPROX_BYTES_PER_TOKEN = 4\n\nconst encoder = new TextEncoder()\nconst decoder = new TextDecoder()\n\n/**\n * UTF-8 byte length of a string.\n *\n * @since 1.0.0\n * @private\n */\nexport const byteLength = (text: string): number => encoder.encode(text).byteLength\n\n/**\n * Approximate token count: ceil(utf8Bytes / 4).\n *\n * @since 1.0.0\n * @private\n */\nexport const approxTokenCount = (text: string): number =>\n  Math.floor((byteLength(text) + APPROX_BYTES_PER_TOKEN - 1) / APPROX_BYTES_PER_TOKEN)\n\n/**\n * Approximate byte budget for a token budget.\n *\n * @since 1.0.0\n * @private\n */\nexport const approxBytesForTokens = (tokens: number): number => tokens * APPROX_BYTES_PER_TOKEN\n\n/**\n * Approximate tokens represented by a byte count: ceil(bytes / 4).\n *\n * @since 1.0.0\n * @private\n */\nexport const approxTokensFromByteCount = (bytes: number): number =>\n  Math.floor((bytes + APPROX_BYTES_PER_TOKEN - 1) / APPROX_BYTES_PER_TOKEN)\n\nconst formatTruncationMarker = (useTokens: boolean, removedCount: number): string =>\n  useTokens ? `\u2026${removedCount} tokens truncated\u2026` : `\u2026${removedCount} chars truncated\u2026`\n\ninterface Split {\n  readonly removedChars: number\n  readonly before: string\n  readonly after: string\n}\n\n/** A UTF-8 continuation byte is `10xxxxxx`; every other byte starts a character. */\nconst isContinuation = (byte: number): boolean => (byte & 0b1100_0000) === 0b1000_0000\n\n/** The last character boundary at or before `offset`. */\nconst boundaryAtOrBefore = (bytes: Uint8Array, offset: number): number => {\n  let at = Math.min(offset, bytes.byteLength)\n  while (at > 0 && at < bytes.byteLength && isContinuation(bytes[at]!)) at--\n  return at\n}\n\n/** The first character boundary at or after `offset`. */\nconst boundaryAtOrAfter = (bytes: Uint8Array, offset: number): number => {\n  let at = Math.max(offset, 0)\n  while (at < bytes.byteLength && isContinuation(bytes[at]!)) at++\n  return at\n}\n\n/**\n * Splits `s` into the head that fits `beginningBytes` and the tail that fits\n * `endBytes`, both cut on UTF-8 character boundaries, and counts the characters\n * dropped between them.\n *\n * The boundaries are read off the encoded bytes rather than by re-encoding one\n * character at a time: a per-character `TextEncoder.encode` costs about two\n * microseconds, which is nineteen seconds for the eight megabytes a bounded\n * capture can hand this function.\n */\nconst splitString = (s: string, beginningBytes: number, endBytes: number): Split => {\n  const bytes = encoder.encode(s)\n  const tailStartTarget = Math.max(bytes.byteLength - endBytes, 0)\n  const prefixEnd = boundaryAtOrBefore(bytes, beginningBytes)\n  const suffixStart = boundaryAtOrAfter(bytes, Math.max(tailStartTarget, prefixEnd))\n  let removedChars = 0\n  for (let at = prefixEnd; at < suffixStart; at++) if (!isContinuation(bytes[at]!)) removedChars++\n  return {\n    removedChars,\n    before: decoder.decode(bytes.subarray(0, prefixEnd)),\n    after: decoder.decode(bytes.subarray(suffixStart))\n  }\n}\n\nconst truncateWithByteEstimate = (s: string, maxBytes: number, useTokens: boolean): string => {\n  if (s === \"\") return \"\"\n  const totalBytes = byteLength(s)\n  if (maxBytes === 0) {\n    return formatTruncationMarker(useTokens, useTokens ? approxTokensFromByteCount(totalBytes) : [...s].length)\n  }\n  if (totalBytes <= maxBytes) return s\n  const leftBudget = Math.floor(maxBytes / 2)\n  const rightBudget = maxBytes - leftBudget\n  const { after, before, removedChars } = splitString(s, leftBudget, rightBudget)\n  const marker = formatTruncationMarker(\n    useTokens,\n    useTokens ? approxTokensFromByteCount(Math.max(totalBytes - maxBytes, 0)) : removedChars\n  )\n  return `${before}${marker}${after}`\n}\n\n/**\n * Middle-truncate to a byte budget with a char-count marker.\n *\n * @since 1.0.0\n * @private\n */\nexport const truncateMiddleChars = (s: string, maxBytes: number): string => truncateWithByteEstimate(s, maxBytes, false)\n\n/**\n * Middle-truncate to an approximate token budget, preserving the beginning\n * and end. Returns the possibly truncated string and the original token\n * count when truncation occurred.\n *\n * @since 1.0.0\n * @private\n */\nexport const truncateMiddleWithTokenBudget = (\n  s: string,\n  maxTokens: number\n): { readonly text: string; readonly originalTokenCount: number | undefined } => {\n  if (s === \"\") return { text: \"\", originalTokenCount: undefined }\n  if (maxTokens > 0 && byteLength(s) <= approxBytesForTokens(maxTokens)) {\n    return { text: s, originalTokenCount: undefined }\n  }\n  const truncated = truncateWithByteEstimate(s, approxBytesForTokens(maxTokens), true)\n  if (truncated === s) return { text: s, originalTokenCount: undefined }\n  return { text: truncated, originalTokenCount: approxTokenCount(s) }\n}\n\nconst countLines = (content: string): number => {\n  if (content === \"\") return 0\n  const parts = content.split(\"\\n\")\n  return parts[parts.length - 1] === \"\" ? parts.length - 1 : parts.length\n}\n\n/**\n * Codex `format_exec_output_for_model`: exit code, wall time, optional line\n * count disclosure, then the (possibly middle-truncated) output.\n *\n * @since 1.0.0\n * @private\n */\nexport const formatExecOutputForModel = (options: {\n  readonly output: string\n  readonly exitCode: number\n  readonly durationSeconds: number\n  readonly maxOutputTokens: number\n  readonly timedOutAfterMs?: number | undefined\n}): string => {\n  const content = options.timedOutAfterMs === undefined\n    ? options.output\n    : `command timed out after ${options.timedOutAfterMs} milliseconds\\n${options.output}`\n  const durationSeconds = Math.round(options.durationSeconds * 10) / 10\n  const totalLines = countLines(content)\n  const formatted = truncateMiddleWithTokenBudget(content, options.maxOutputTokens).text\n  const sections = [\n    `Exit code: ${options.exitCode}`,\n    `Wall time: ${durationSeconds} seconds`\n  ]\n  if (totalLines !== countLines(formatted)) sections.push(`Total output lines: ${totalLines}`)\n  sections.push(\"Output:\")\n  sections.push(formatted)\n  return sections.join(\"\\n\")\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/internal/Declaration.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Shared declaration helpers for the standard flows.
+ *
+ * @since 1.0.0
+ */
+import type * as Capability from "@smthrs/capability/Capability";
+import * as Effects from "@smthrs/core/Effects";
+/**
+ * Options accepted by {@link envelope}.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface EnvelopeOptions {
+    readonly tier: "sealed" | "compensable" | "irreversible";
+    readonly mode: "hermetic" | "expected";
+    readonly reads: Iterable<string>;
+    readonly writes: Iterable<string>;
+}
+/**
+ * Builds a deterministic effect declaration for a standard flow.
+ *
+ * Every standard flow serializes on conflict: the library owns no lane
+ * partitioning of its own, so the conservative choice is the safe one.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const envelope: (options: EnvelopeOptions) => Effects.Declaration;
+/**
+ * Formats a capability request as the `action:resource` string carried on a
+ * flow declaration.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const capability: (action: Capability.Action, resource: string) => string;
+/**
+ * The read glob covering everything under one search root.
+ *
+ * `glob` and `grep` narrow their conservative `/**` declaration to the root the
+ * call actually names, and a declaration that disagreed between the two would
+ * make the same search reserve different paths depending on which flow ran it.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const rootSubtree: (root: string) => string;
+//# sourceMappingURL=Declaration.d.ts.map

package/dist/cjs/internal/Declaration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Declaration.d.ts","sourceRoot":"","sources":["../../../src/internal/Declaration.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,KAAK,UAAU,MAAM,+BAA+B,CAAA;AAChE,OAAO,KAAK,OAAO,MAAM,sBAAsB,CAAA;AAE/C;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,aAAa,GAAG,cAAc,CAAA;IACxD,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAAA;IACtC,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAA;IAChC,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAA;CAClC;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ,GAAI,SAAS,eAAe,KAAG,OAAO,CAAC,WAOxD,CAAA;AAEJ;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,GAAI,QAAQ,UAAU,CAAC,MAAM,EAAE,UAAU,MAAM,KAAG,MAAiC,CAAA;AAE1G;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW,GAAI,MAAM,MAAM,KAAG,MAAiE,CAAA"}

package/dist/cjs/internal/Declaration.js

@@ -0,0 +1,46 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Declaration_exports = {};
+__export(Declaration_exports, {
+  capability: () => capability,
+  envelope: () => envelope,
+  rootSubtree: () => rootSubtree
+});
+module.exports = __toCommonJS(Declaration_exports);
+var Effects = __toESM(require("@smthrs/core/Effects"), 1);
+const envelope = (options) => Effects.make({
+  reads: options.reads,
+  writes: options.writes,
+  mode: options.mode,
+  onConflict: "serialize",
+  tier: options.tier
+});
+const capability = (action, resource) => `${action}:${resource}`;
+const rootSubtree = (root) => root === "/" ? "/**" : `${root.replace(/\/+$/, "")}/**`;
+//# sourceMappingURL=Declaration.js.map

package/dist/cjs/internal/Declaration.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/Declaration.ts"],
+  "sourcesContent": ["/**\n * Shared declaration helpers for the standard flows.\n *\n * @since 1.0.0\n */\n\nimport type * as Capability from \"@smthrs/capability/Capability\"\nimport * as Effects from \"@smthrs/core/Effects\"\n\n/**\n * Options accepted by {@link envelope}.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface EnvelopeOptions {\n  readonly tier: \"sealed\" | \"compensable\" | \"irreversible\"\n  readonly mode: \"hermetic\" | \"expected\"\n  readonly reads: Iterable<string>\n  readonly writes: Iterable<string>\n}\n\n/**\n * Builds a deterministic effect declaration for a standard flow.\n *\n * Every standard flow serializes on conflict: the library owns no lane\n * partitioning of its own, so the conservative choice is the safe one.\n *\n * @category constructors\n * @since 1.0.0\n */\nexport const envelope = (options: EnvelopeOptions): Effects.Declaration =>\n  Effects.make({\n    reads: options.reads,\n    writes: options.writes,\n    mode: options.mode,\n    onConflict: \"serialize\",\n    tier: options.tier\n  })\n\n/**\n * Formats a capability request as the `action:resource` string carried on a\n * flow declaration.\n *\n * @category constructors\n * @since 1.0.0\n */\nexport const capability = (action: Capability.Action, resource: string): string => `${action}:${resource}`\n\n/**\n * The read glob covering everything under one search root.\n *\n * `glob` and `grep` narrow their conservative `/**` declaration to the root the\n * call actually names, and a declaration that disagreed between the two would\n * make the same search reserve different paths depending on which flow ran it.\n *\n * @category constructors\n * @since 1.0.0\n */\nexport const rootSubtree = (root: string): string => root === \"/\" ? \"/**\" : `${root.replace(/\\/+$/, \"\")}/**`\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,cAAyB;AAwBlB,MAAM,WAAW,CAAC,YACvB,QAAQ,KAAK;AAAA,EACX,OAAO,QAAQ;AAAA,EACf,QAAQ,QAAQ;AAAA,EAChB,MAAM,QAAQ;AAAA,EACd,YAAY;AAAA,EACZ,MAAM,QAAQ;AAChB,CAAC;AASI,MAAM,aAAa,CAAC,QAA2B,aAA6B,GAAG,MAAM,IAAI,QAAQ;AAYjG,MAAM,cAAc,CAAC,SAAyB,SAAS,MAAM,QAAQ,GAAG,KAAK,QAAQ,QAAQ,EAAE,CAAC;",
+  "names": []
+}

package/dist/cjs/internal/Diagnostics.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Keeps a bound language server in step with the files the mutation flows
+ * write, and reads back the errors an edit leaves.
+ *
+ * The server is optional: a host that binds no `LanguageServer` edits files
+ * exactly as before, and a server that fails or times out never fails the
+ * write that already happened.
+ *
+ * @since 1.0.0
+ */
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as LanguageServer from "../LanguageServer.ts";
+/**
+ * Most errors attached to one result.
+ *
+ * @category internal
+ * @since 1.0.0
+ */
+export declare const MAX_ERRORS = 20;
+/**
+ * One error-severity diagnostic, at its 1-based position.
+ *
+ * @category internal
+ * @since 1.0.0
+ */
+export declare const Problem: Schema.Struct<{
+    readonly line: Schema.Number;
+    readonly character: Schema.Number;
+    readonly message: Schema.String;
+}>;
+/**
+ * A decoded {@link Problem}.
+ *
+ * @category internal
+ * @since 1.0.0
+ */
+export type Problem = typeof Problem.Type;
+/**
+ * The error-severity items of a document diagnostic report, 1-based.
+ *
+ * @category internal
+ * @since 1.0.0
+ */
+export declare const errors: (report: unknown) => ReadonlyArray<Problem>;
+/**
+ * Sends a written file's new text to the bound server, if any. Succeeds with
+ * the server that took it.
+ *
+ * @category internal
+ * @since 1.0.0
+ */
+export declare const sync: (path: string, text: string) => Effect.Effect<LanguageServer.LanguageServer | undefined>;
+/**
+ * Tells the bound server, if any, that a file is gone.
+ *
+ * @category internal
+ * @since 1.0.0
+ */
+export declare const close: (path: string) => Effect.Effect<void>;
+/**
+ * Tells the bound server, if any, to re-read every file it has open, after
+ * something other than the mutation flows may have changed them.
+ *
+ * @category internal
+ * @since 1.0.0
+ */
+export declare const refresh: Effect.Effect<void>;
+/**
+ * The errors `server` reports for `path`, or `undefined` when it could not
+ * answer.
+ *
+ * @category internal
+ * @since 1.0.0
+ */
+export declare const errorsOf: (server: LanguageServer.LanguageServer, path: string) => Effect.Effect<ReadonlyArray<Problem> | undefined>;
+//# sourceMappingURL=Diagnostics.d.ts.map

package/dist/cjs/internal/Diagnostics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Diagnostics.d.ts","sourceRoot":"","sources":["../../../src/internal/Diagnostics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,cAAc,MAAM,sBAAsB,CAAA;AAEtD;;;;;GAKG;AACH,eAAO,MAAM,UAAU,KAAK,CAAA;AAE5B;;;;;GAKG;AACH,eAAO,MAAM,OAAO;;;;EAIlB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,OAAO,GAAG,OAAO,OAAO,CAAC,IAAI,CAAA;AAOzC;;;;;GAKG;AACH,eAAO,MAAM,MAAM,GAAI,QAAQ,OAAO,KAAG,aAAa,CAAC,OAAO,CAe7D,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,GAAI,MAAM,MAAM,EAAE,MAAM,MAAM,KAAG,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,cAAc,GAAG,SAAS,CAUtG,CAAA;AAEH;;;;;GAKG;AACH,eAAO,MAAM,KAAK,GAAI,MAAM,MAAM,KAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAMpD,CAAA;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAKvC,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,GACnB,QAAQ,cAAc,CAAC,cAAc,EACrC,MAAM,MAAM,KACX,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,OAAO,CAAC,GAAG,SAAS,CAIhD,CAAA"}

package/dist/cjs/internal/Diagnostics.js

@@ -0,0 +1,89 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Diagnostics_exports = {};
+__export(Diagnostics_exports, {
+  MAX_ERRORS: () => MAX_ERRORS,
+  Problem: () => Problem,
+  close: () => close,
+  errors: () => errors,
+  errorsOf: () => errorsOf,
+  refresh: () => refresh,
+  sync: () => sync
+});
+module.exports = __toCommonJS(Diagnostics_exports);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Option = __toESM(require("effect/Option"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var LanguageServer = __toESM(require("../LanguageServer.js"), 1);
+const MAX_ERRORS = 20;
+const Problem = Schema.Struct({
+  line: Schema.Number.annotate({ description: "1-based line" }),
+  character: Schema.Number.annotate({ description: "1-based character" }),
+  message: Schema.String
+});
+const record = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+const errors = (report) => {
+  const items = record(report)?.items;
+  if (!Array.isArray(items)) return [];
+  const found = [];
+  for (const item of items) {
+    const diagnostic = record(item);
+    const start = record(record(diagnostic?.range)?.start);
+    if (diagnostic?.severity !== 1 || typeof diagnostic.message !== "string" || typeof start?.line !== "number" || typeof start.character !== "number") continue;
+    found.push({ line: start.line + 1, character: start.character + 1, message: diagnostic.message });
+    if (found.length === MAX_ERRORS) break;
+  }
+  return found;
+};
+const sync = (path, text) => Effect.serviceOption(LanguageServer.LanguageServer).pipe(
+  Effect.flatMap(Option.match({
+    onNone: () => Effect.succeed(void 0),
+    onSome: (server) => server.sync(path, text).pipe(
+      Effect.as(server),
+      Effect.orElseSucceed(() => void 0)
+    )
+  }))
+);
+const close = (path) => Effect.serviceOption(LanguageServer.LanguageServer).pipe(
+  Effect.flatMap(Option.match({
+    onNone: () => Effect.void,
+    onSome: (server) => server.close(path).pipe(Effect.ignore)
+  }))
+);
+const refresh = Effect.serviceOption(LanguageServer.LanguageServer).pipe(
+  Effect.flatMap(Option.match({
+    onNone: () => Effect.void,
+    onSome: (server) => server.refresh.pipe(Effect.ignore)
+  }))
+);
+const errorsOf = (server, path) => server.diagnostics(path).pipe(
+  Effect.map(errors),
+  Effect.orElseSucceed(() => void 0)
+);
+//# sourceMappingURL=Diagnostics.js.map

package/dist/cjs/internal/Diagnostics.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/Diagnostics.ts"],
+  "sourcesContent": ["/**\n * Keeps a bound language server in step with the files the mutation flows\n * write, and reads back the errors an edit leaves.\n *\n * The server is optional: a host that binds no `LanguageServer` edits files\n * exactly as before, and a server that fails or times out never fails the\n * write that already happened.\n *\n * @since 1.0.0\n */\n\nimport * as Effect from \"effect/Effect\"\nimport * as Option from \"effect/Option\"\nimport * as Schema from \"effect/Schema\"\nimport * as LanguageServer from \"../LanguageServer.ts\"\n\n/**\n * Most errors attached to one result.\n *\n * @category internal\n * @since 1.0.0\n */\nexport const MAX_ERRORS = 20\n\n/**\n * One error-severity diagnostic, at its 1-based position.\n *\n * @category internal\n * @since 1.0.0\n */\nexport const Problem = Schema.Struct({\n  line: Schema.Number.annotate({ description: \"1-based line\" }),\n  character: Schema.Number.annotate({ description: \"1-based character\" }),\n  message: Schema.String\n})\n\n/**\n * A decoded {@link Problem}.\n *\n * @category internal\n * @since 1.0.0\n */\nexport type Problem = typeof Problem.Type\n\nconst record = (value: unknown): Readonly<Record<string, unknown>> | undefined =>\n  typeof value === \"object\" && value !== null && !Array.isArray(value)\n    ? value as Readonly<Record<string, unknown>>\n    : undefined\n\n/**\n * The error-severity items of a document diagnostic report, 1-based.\n *\n * @category internal\n * @since 1.0.0\n */\nexport const errors = (report: unknown): ReadonlyArray<Problem> => {\n  const items = record(report)?.items\n  if (!Array.isArray(items)) return []\n  const found: Array<Problem> = []\n  for (const item of items) {\n    const diagnostic = record(item)\n    const start = record(record(diagnostic?.range)?.start)\n    if (\n      diagnostic?.severity !== 1 || typeof diagnostic.message !== \"string\" ||\n      typeof start?.line !== \"number\" || typeof start.character !== \"number\"\n    ) continue\n    found.push({ line: start.line + 1, character: start.character + 1, message: diagnostic.message })\n    if (found.length === MAX_ERRORS) break\n  }\n  return found\n}\n\n/**\n * Sends a written file's new text to the bound server, if any. Succeeds with\n * the server that took it.\n *\n * @category internal\n * @since 1.0.0\n */\nexport const sync = (path: string, text: string): Effect.Effect<LanguageServer.LanguageServer | undefined> =>\n  Effect.serviceOption(LanguageServer.LanguageServer).pipe(\n    Effect.flatMap(Option.match({\n      onNone: () => Effect.succeed(undefined),\n      onSome: (server) =>\n        server.sync(path, text).pipe(\n          Effect.as(server),\n          Effect.orElseSucceed(() => undefined)\n        )\n    }))\n  )\n\n/**\n * Tells the bound server, if any, that a file is gone.\n *\n * @category internal\n * @since 1.0.0\n */\nexport const close = (path: string): Effect.Effect<void> =>\n  Effect.serviceOption(LanguageServer.LanguageServer).pipe(\n    Effect.flatMap(Option.match({\n      onNone: () => Effect.void,\n      onSome: (server) => server.close(path).pipe(Effect.ignore)\n    }))\n  )\n\n/**\n * Tells the bound server, if any, to re-read every file it has open, after\n * something other than the mutation flows may have changed them.\n *\n * @category internal\n * @since 1.0.0\n */\nexport const refresh: Effect.Effect<void> = Effect.serviceOption(LanguageServer.LanguageServer).pipe(\n  Effect.flatMap(Option.match({\n    onNone: () => Effect.void,\n    onSome: (server) => server.refresh.pipe(Effect.ignore)\n  }))\n)\n\n/**\n * The errors `server` reports for `path`, or `undefined` when it could not\n * answer.\n *\n * @category internal\n * @since 1.0.0\n */\nexport const errorsOf = (\n  server: LanguageServer.LanguageServer,\n  path: string\n): Effect.Effect<ReadonlyArray<Problem> | undefined> =>\n  server.diagnostics(path).pipe(\n    Effect.map(errors),\n    Effect.orElseSucceed(() => undefined)\n  )\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,aAAwB;AACxB,aAAwB;AACxB,aAAwB;AACxB,qBAAgC;AAQzB,MAAM,aAAa;AAQnB,MAAM,UAAU,OAAO,OAAO;AAAA,EACnC,MAAM,OAAO,OAAO,SAAS,EAAE,aAAa,eAAe,CAAC;AAAA,EAC5D,WAAW,OAAO,OAAO,SAAS,EAAE,aAAa,oBAAoB,CAAC;AAAA,EACtE,SAAS,OAAO;AAClB,CAAC;AAUD,MAAM,SAAS,CAAC,UACd,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK,IAC/D,QACA;AAQC,MAAM,SAAS,CAAC,WAA4C;AACjE,QAAM,QAAQ,OAAO,MAAM,GAAG;AAC9B,MAAI,CAAC,MAAM,QAAQ,KAAK,EAAG,QAAO,CAAC;AACnC,QAAM,QAAwB,CAAC;AAC/B,aAAW,QAAQ,OAAO;AACxB,UAAM,aAAa,OAAO,IAAI;AAC9B,UAAM,QAAQ,OAAO,OAAO,YAAY,KAAK,GAAG,KAAK;AACrD,QACE,YAAY,aAAa,KAAK,OAAO,WAAW,YAAY,YAC5D,OAAO,OAAO,SAAS,YAAY,OAAO,MAAM,cAAc,SAC9D;AACF,UAAM,KAAK,EAAE,MAAM,MAAM,OAAO,GAAG,WAAW,MAAM,YAAY,GAAG,SAAS,WAAW,QAAQ,CAAC;AAChG,QAAI,MAAM,WAAW,WAAY;AAAA,EACnC;AACA,SAAO;AACT;AASO,MAAM,OAAO,CAAC,MAAc,SACjC,OAAO,cAAc,eAAe,cAAc,EAAE;AAAA,EAClD,OAAO,QAAQ,OAAO,MAAM;AAAA,IAC1B,QAAQ,MAAM,OAAO,QAAQ,MAAS;AAAA,IACtC,QAAQ,CAAC,WACP,OAAO,KAAK,MAAM,IAAI,EAAE;AAAA,MACtB,OAAO,GAAG,MAAM;AAAA,MAChB,OAAO,cAAc,MAAM,MAAS;AAAA,IACtC;AAAA,EACJ,CAAC,CAAC;AACJ;AAQK,MAAM,QAAQ,CAAC,SACpB,OAAO,cAAc,eAAe,cAAc,EAAE;AAAA,EAClD,OAAO,QAAQ,OAAO,MAAM;AAAA,IAC1B,QAAQ,MAAM,OAAO;AAAA,IACrB,QAAQ,CAAC,WAAW,OAAO,MAAM,IAAI,EAAE,KAAK,OAAO,MAAM;AAAA,EAC3D,CAAC,CAAC;AACJ;AASK,MAAM,UAA+B,OAAO,cAAc,eAAe,cAAc,EAAE;AAAA,EAC9F,OAAO,QAAQ,OAAO,MAAM;AAAA,IAC1B,QAAQ,MAAM,OAAO;AAAA,IACrB,QAAQ,CAAC,WAAW,OAAO,QAAQ,KAAK,OAAO,MAAM;AAAA,EACvD,CAAC,CAAC;AACJ;AASO,MAAM,WAAW,CACtB,QACA,SAEA,OAAO,YAAY,IAAI,EAAE;AAAA,EACvB,OAAO,IAAI,MAAM;AAAA,EACjB,OAAO,cAAc,MAAM,MAAS;AACtC;",
+  "names": []
+}