@smthrs/harness 0.0.0-stage → 1.0.0-rc.4

package/dist/cjs/internal/demandText.js

@@ -0,0 +1,70 @@
+"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 demandText_exports = {};
+__export(demandText_exports, {
+  claim: () => claim,
+  narrowOnly: () => narrowOnly,
+  narrowed: () => narrowed,
+  readOnly: () => readOnly,
+  repeat: () => repeat,
+  unmoved: () => unmoved,
+  unresolved: () => unresolved
+});
+module.exports = __toCommonJS(demandText_exports);
+const readOnly = (cap, frames) => `Read-only discipline \u2014 ${frames} consecutive frames have made no call that declares a write, and this run's read-only budget is ${cap}. If the current request is already answered, call ctx.done(answer) now. A conversational or read-only answer needs no invented edit or command. If a workspace change is still required, land an edit you can already name the evidence for \u2014 the file, the change, and the check you have watched fail that will now pass. If more evidence is needed, call ctx.justify("<the evidence you are still missing, the exact call that will get it, and what that makes the next frames do differently from these ${frames}>"). Do not write something merely to answer this notice. A restore, a revert, an overwrite from captured output, or any edit whose evidence you cannot name is worse than another read-only frame, because it destroys work this run has already done. A justification is recorded and buys ${cap} quiet frames; it does not reset this counter, and one that names the same next step the last quiet frame named has bought a repeat of that frame. At ${cap * 2} consecutive read-only frames the run stops as a failure, so ${cap * 2 - frames} frames remain to answer the request or make the required change.`;
+const repeat = (frames, cap) => `Repeated observation \u2014 the last ${frames} frames issued only calls this run had already issued, byte for byte, and none of them changed the workspace. You are re-confirming what you already know: a call repeated over an unchanged tree returns what it returned the first time. If you have already made a change, it is real and it is recorded, and looking at it again cannot tell you whether it is the right change \u2014 what is left to establish is the mechanism, not the presence.
+
+Spend the next frame on evidence you do not have. Three places hold some, and none of them is the diff:
+- the failing check itself \u2014 what it asserts, the values it asserts about, and the setup that produces them;
+- the history of the symbol you changed \u2014 \`git log -L <start>,<end>:<file>\` over its line range, or \`git blame\` on the line \u2014 which says why it is written the way it is and what it was written to handle;
+- a different site \u2014 the callers of the symbol rather than its definition, which is where a wrong mechanism shows first.
+
+If no call you can name would tell you something you do not already know, say which mechanism you now believe is wrong and change that instead. This notice returns after another ${cap} repeated frames.`;
+const unmoved = (opened, closed) => `Unmoved workspace \u2014 the tree you are completing on is the tree this run was handed.
+
+- digest the run opened on: ${opened}
+- digest this frame closed on: ${closed}
+
+Nothing in this workspace differs from the tree this run opened on, so there is no change behind the completion you wrote. Make the change, or complete again stating that no change is needed and naming what you ran to conclude it \u2014 the calls you made, what they printed, and why that shows the behaviour asked for is already the behaviour this tree has. Both answers are accepted exactly as you write them and nothing re-checks either one; "no change is needed" with its working shown is a finished answer, and the same words with nothing behind them are the completion you just had handed back. Nothing makes the change for you, and what you return next is the answer that stands.`;
+const unresolved = (flow, failed, instead) => `Unanswered failure \u2014 a check you ran over this exact tree reported a failing exit status, and you went back to what it covered with a different command instead of running it again.
+
+- the check that failed, over the tree you are completing on: ${flow} ${failed}
+- the reading you took instead: ${flow} ${instead}
+
+The second names the same subject as the first, so the run itself treated that subject as still open; the first was never run again, and its result is the one this completion is standing on. Fix what it reported and run it again, byte for byte, and complete once you have seen what it prints; or complete and state in your output why the failures it reported are expected and not yours. Nothing re-runs it for you, and what you return next is the answer that stands.`;
+const narrowed = (flow, broader, narrower) => `Narrowed verification \u2014 your last verification is narrower than a check this run has already run in full, and the workspace has changed since that broader check last ran.
+
+- the broader check, last run before your latest change: ${flow} ${broader}
+- the check this frame ran instead: ${flow} ${narrower}
+
+The second repeats every term of the first and adds conditions to it, so it reports on a part of what the first covered and says nothing about the rest \u2014 and the rest is exactly where a change breaks something that was passing. Re-run ${flow} with that earlier input, byte for byte, and complete once you have seen what it prints; or complete and state in your output why that check no longer applies to the change you made. Nothing re-runs it for you, and what you return next is the answer that stands.`;
+const narrowOnly = (flow, check, targets) => `Only reading \u2014 the check you are completing on is the only reading this run has of what it names.
+
+- the check: ${flow} ${check}
+- what it names: ${targets.join(", ")}
+
+Every one of those this run has looked at somewhere else, but no other call it made covers them all, so nothing in this run says what they report on their own. Any term this check carries beyond them \u2014 a filter, a selector, a subset of cases, a flag that stops early \u2014 is a condition you have never taken off, and what a condition hides is exactly where a change breaks something that was passing. Run ${flow} over the same subjects with those conditions removed and complete once you have seen what it prints; or complete and state in your output that it carries no condition and the reading is already whole. Nothing re-runs it for you, and what you return next is the answer that stands.`;
+const claim = () => `Completion review \u2014 reconsider whether your completion answers the current request and whether any claimed actions or results are supported by this run's record.
+
+Answer the current request directly, keeping its requested format. A purely conversational answer needs no file edit, command, or verification. Do not add a work report when the person asked only for an answer.
+
+If you claim a command or result, use recorded evidence: make an allowed call needed to obtain it, or remove the unsupported claim and say plainly what remains unchecked when relevant. A completion that reports work honestly left undone is not refused for that alone.
+
+The next completion is judged again. A repeated claim of work this run never recorded can end the run with no answer.`;
+//# sourceMappingURL=demandText.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/demandText.ts"],
+  "sourcesContent": ["/**\n * Canonical renderings of controller interventions recorded in the journal.\n *\n * `CellTurn` uses these strings when it builds the live model window and\n * `Transcript` uses the same functions when it rebuilds that window. Keeping\n * the rendering here makes an intervention event sufficient to reproduce the\n * exact user message it represented.\n *\n * @since 1.0.0-rc.0\n * @private\n */\n\n/**\n * Renders the read-only-discipline intervention.\n *\n * It asks for a decision rather than a token write. An answerable request can\n * complete without inventing work. An unfinished workspace change still needs\n * evidence or a justification for more observation, and destructive\n * writes made only to satisfy the notice are explicitly refused. A\n * justification must name how later frames differ from the quiet ones so the\n * run cannot buy a repeat by restating its plan.\n *\n * @category conversions\n * @since 1.0.0-rc.0\n * @private\n */\nexport const readOnly = (cap: number, frames: number): string =>\n  `Read-only discipline \u2014 ${frames} consecutive frames have made no call that declares a write, and this run's read-only budget is ${cap}. If the current request is already answered, call ctx.done(answer) now. A conversational or read-only answer needs no invented edit or command. If a workspace change is still required, land an edit you can already name the evidence for \u2014 the file, the change, and the check you have watched fail that will now pass. If more evidence is needed, call ctx.justify(\"<the evidence you are still missing, the exact call that will get it, and what that makes the next frames do differently from these ${frames}>\"). Do not write something merely to answer this notice. A restore, a revert, an overwrite from captured output, or any edit whose evidence you cannot name is worse than another read-only frame, because it destroys work this run has already done. A justification is recorded and buys ${cap} quiet frames; it does not reset this counter, and one that names the same next step the last quiet frame named has bought a repeat of that frame. At ${\n    cap * 2\n  } consecutive read-only frames the run stops as a failure, so ${\n    cap * 2 - frames\n  } frames remain to answer the request or make the required change.`\n\n/**\n * Renders the repeated-observation intervention.\n *\n * This is separate from the read-only demand because a repeating run has\n * often already edited. It redirects the run from re-reading that edit toward\n * mechanism evidence: the failing check, symbol history, or another caller.\n *\n * @category conversions\n * @since 1.0.0-rc.0\n * @private\n */\nexport const repeat = (frames: number, cap: number): string =>\n  `Repeated observation \u2014 the last ${frames} frames issued only calls this run had already issued, byte for byte, and none of them changed the workspace. You are re-confirming what you already know: a call repeated over an unchanged tree returns what it returned the first time. If you have already made a change, it is real and it is recorded, and looking at it again cannot tell you whether it is the right change \u2014 what is left to establish is the mechanism, not the presence.\n\nSpend the next frame on evidence you do not have. Three places hold some, and none of them is the diff:\n- the failing check itself \u2014 what it asserts, the values it asserts about, and the setup that produces them;\n- the history of the symbol you changed \u2014 \\`git log -L <start>,<end>:<file>\\` over its line range, or \\`git blame\\` on the line \u2014 which says why it is written the way it is and what it was written to handle;\n- a different site \u2014 the callers of the symbol rather than its definition, which is where a wrong mechanism shows first.\n\nIf no call you can name would tell you something you do not already know, say which mechanism you now believe is wrong and change that instead. This notice returns after another ${cap} repeated frames.`\n\n/**\n * Renders the unchanged-workspace completion intervention.\n *\n * @category conversions\n * @since 1.0.0-rc.0\n * @private\n */\nexport const unmoved = (opened: string, closed: string): string =>\n  `Unmoved workspace \u2014 the tree you are completing on is the tree this run was handed.\n\n- digest the run opened on: ${opened}\n- digest this frame closed on: ${closed}\n\nNothing in this workspace differs from the tree this run opened on, so there is no change behind the completion you wrote. Make the change, or complete again stating that no change is needed and naming what you ran to conclude it \u2014 the calls you made, what they printed, and why that shows the behaviour asked for is already the behaviour this tree has. Both answers are accepted exactly as you write them and nothing re-checks either one; \"no change is needed\" with its working shown is a finished answer, and the same words with nothing behind them are the completion you just had handed back. Nothing makes the change for you, and what you return next is the answer that stands.`\n\n/**\n * Renders the unresolved-failure completion intervention.\n *\n * @category conversions\n * @since 1.0.0-rc.0\n * @private\n */\nexport const unresolved = (flow: string, failed: string, instead: string): string =>\n  `Unanswered failure \u2014 a check you ran over this exact tree reported a failing exit status, and you went back to what it covered with a different command instead of running it again.\n\n- the check that failed, over the tree you are completing on: ${flow} ${failed}\n- the reading you took instead: ${flow} ${instead}\n\nThe second names the same subject as the first, so the run itself treated that subject as still open; the first was never run again, and its result is the one this completion is standing on. Fix what it reported and run it again, byte for byte, and complete once you have seen what it prints; or complete and state in your output why the failures it reported are expected and not yours. Nothing re-runs it for you, and what you return next is the answer that stands.`\n\n/**\n * Renders the narrowed-check completion intervention.\n *\n * @category conversions\n * @since 1.0.0-rc.0\n * @private\n */\nexport const narrowed = (flow: string, broader: string, narrower: string): string =>\n  `Narrowed verification \u2014 your last verification is narrower than a check this run has already run in full, and the workspace has changed since that broader check last ran.\n\n- the broader check, last run before your latest change: ${flow} ${broader}\n- the check this frame ran instead: ${flow} ${narrower}\n\nThe second repeats every term of the first and adds conditions to it, so it reports on a part of what the first covered and says nothing about the rest \u2014 and the rest is exactly where a change breaks something that was passing. Re-run ${flow} with that earlier input, byte for byte, and complete once you have seen what it prints; or complete and state in your output why that check no longer applies to the change you made. Nothing re-runs it for you, and what you return next is the answer that stands.`\n\n/**\n * Renders the only-reading completion intervention.\n *\n * @category conversions\n * @since 1.0.0-rc.0\n * @private\n */\nexport const narrowOnly = (flow: string, check: string, targets: ReadonlyArray<string>): string =>\n  `Only reading \u2014 the check you are completing on is the only reading this run has of what it names.\n\n- the check: ${flow} ${check}\n- what it names: ${targets.join(\", \")}\n\nEvery one of those this run has looked at somewhere else, but no other call it made covers them all, so nothing in this run says what they report on their own. Any term this check carries beyond them \u2014 a filter, a selector, a subset of cases, a flag that stops early \u2014 is a condition you have never taken off, and what a condition hides is exactly where a change breaks something that was passing. Run ${flow} over the same subjects with those conditions removed and complete once you have seen what it prints; or complete and state in your output that it carries no condition and the reading is already whole. Nothing re-runs it for you, and what you return next is the answer that stands.`\n\n/**\n * Renders the completion-review intervention.\n *\n * Any of the three completion questions can ask for another frame. A low\n * completeness reading does not establish that the run invented work, so the\n * notice asks for a direct answer and makes evidence conditional on the\n * actions or results that answer actually claims. A conversational answer\n * needs no work report and must retain the person's requested format.\n *\n * The task is not quoted back. It is in the run's prefix on every frame, so a\n * quote would buy nothing and cost the window the run has to answer in, and\n * leaving it out is also what lets this text be rebuilt from the event alone.\n * No probability is quoted either: a number is journal material for a grader,\n * and in front of a model it is a score to negotiate.\n *\n * The text still warns about the narrower refusal: repeated claims of work\n * the record does not carry can end the run. Honest reports of work left\n * undone remain valid answers when that is what the run can report.\n *\n * @category conversions\n * @since 1.0.0-rc.0\n * @private\n */\nexport const claim = (): string =>\n  `Completion review \u2014 reconsider whether your completion answers the current request and whether any claimed actions or results are supported by this run's record.\n\nAnswer the current request directly, keeping its requested format. A purely conversational answer needs no file edit, command, or verification. Do not add a work report when the person asked only for an answer.\n\nIf you claim a command or result, use recorded evidence: make an allowed call needed to obtain it, or remove the unsupported claim and say plainly what remains unchecked when relevant. A completion that reports work honestly left undone is not refused for that alone.\n\nThe next completion is judged again. A repeated claim of work this run never recorded can end the run with no answer.`\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA0BO,MAAM,WAAW,CAAC,KAAa,WACpC,+BAA0B,MAAM,mGAAmG,GAAG,ufAAkf,MAAM,gSAAgS,GAAG,yJAC/5B,MAAM,CACR,gEACE,MAAM,IAAI,MACZ;AAaK,MAAM,SAAS,CAAC,QAAgB,QACrC,wCAAmC,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oLAOyI,GAAG;AAShL,MAAM,UAAU,CAAC,QAAgB,WACtC;AAAA;AAAA,8BAE4B,MAAM;AAAA,iCACH,MAAM;AAAA;AAAA;AAWhC,MAAM,aAAa,CAAC,MAAc,QAAgB,YACvD;AAAA;AAAA,gEAE8D,IAAI,IAAI,MAAM;AAAA,kCAC5C,IAAI,IAAI,OAAO;AAAA;AAAA;AAW1C,MAAM,WAAW,CAAC,MAAc,SAAiB,aACtD;AAAA;AAAA,2DAEyD,IAAI,IAAI,OAAO;AAAA,sCACpC,IAAI,IAAI,QAAQ;AAAA;AAAA,kPAEuL,IAAI;AAS1O,MAAM,aAAa,CAAC,MAAc,OAAe,YACtD;AAAA;AAAA,eAEa,IAAI,IAAI,KAAK;AAAA,mBACT,QAAQ,KAAK,IAAI,CAAC;AAAA;AAAA,8ZAE+W,IAAI;AAyBjZ,MAAM,QAAQ,MACnB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;",
+  "names": []
+}

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

@@ -0,0 +1,109 @@
+/**
+ * Honest shortening.
+ *
+ * Every place this harness puts bytes in front of a model is bounded, and every
+ * one of those bounds used to be spelled the same way: slice, append `…`, move
+ * on. A model reading that cannot tell a value that ends in an ellipsis from a
+ * value that was cut, cannot tell how much it lost, and — the expensive part —
+ * cannot tell how to get the rest back, so it buys the same bytes again. Three
+ * of the five most expensive instances of the r90 wave spent real money
+ * re-fetching a region the run had already rendered and silently clipped
+ * (`pydata__xarray-7229` $0.76, `sphinx-doc__sphinx-8721` $0.36,
+ * `pytest-dev__pytest-6197` $0.19).
+ *
+ * So a shortened value states three things: that it was shortened, how many
+ * bytes are missing, and the id that brings them back. The id is a sentence the
+ * caller supplies, because only the caller knows whether the thing is a state
+ * key (`render`), a settled call (`recall`), or something the model must fetch
+ * again.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+/**
+ * The first `limit` UTF-8 bytes of `text`, stopping before a code point that
+ * would cross the bound.
+ *
+ * UTF-8 bytes and UTF-16 indexes do not share boundaries for multibyte text, so
+ * a cut may keep fewer bytes than the caller offered. Every bound here is a
+ * ceiling: giving bytes back is allowed; taking one is not. Walking by code
+ * point also subsumes the surrogate-pair guarantee — no half of an astral
+ * character can survive on either side of a cut.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export declare const headSlice: (text: string, limit: number) => string;
+/**
+ * The last `limit` UTF-8 bytes of `text`, starting on a code-point boundary.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export declare const tailSlice: (text: string, limit: number) => string;
+/**
+ * Shortens an already-shortened text from the middle, counting against the
+ * whole it came from.
+ *
+ * A value can be bounded twice: once where the host copies it out of the
+ * sandbox, and again where the frame apportions its print budget across the
+ * statements that share it. Counting the second reduction against what survived
+ * the first would report a value as smaller than it is — the exact dishonesty
+ * this module exists to abolish — so `whole` is stated by the caller, which is
+ * the only place that still knows it, and the notice always names the original
+ * size.
+ *
+ * `text` must be the head and tail of the original, in order: every reduction
+ * here keeps both ends, so slicing the ends of a reduced value is the same as
+ * slicing the ends of the value it came from.
+ *
+ * The count is what the two ends actually left behind rather than `whole -
+ * limit`, because a cut that stopped before a multibyte code point can keep
+ * fewer bytes than the limit allowed and the notice names the real number.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export declare const middleFrom: (text: string, whole: number, limit: number, recall: string) => string;
+/**
+ * The most one {@link middleFrom} notice can cost, for a value of this size.
+ *
+ * A caller apportioning one budget across several values has to reserve the
+ * notices before it can hand out the rest, or it hands out bytes the notices
+ * then take back and something downstream cuts the notice in half. The bound is
+ * exact: the dropped count is never larger than the whole, so the notice for a
+ * value shortened to nothing is the longest notice that value can produce.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export declare const noticeCost: (whole: number, recall: string) => number;
+/**
+ * Shortens text from the middle, keeping both ends.
+ *
+ * The two ends are where a file excerpt, a diff, or a test log identifies
+ * itself; the middle is where the repetition is. `recall` is the sentence that
+ * says how to see what was dropped.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export declare const middle: (text: string, limit: number, recall: string) => string;
+/**
+ * Shortens text from the end, keeping the head.
+ *
+ * Used for the one-line summaries a ledger prints, where the head is the whole
+ * of what identifies the line and the tail is detail.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export declare const head: (text: string, limit: number, recall: string) => string;
+//# sourceMappingURL=elide.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"elide.d.ts","sourceRoot":"","sources":["../../../src/internal/elide.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAIH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,SAAS,GAAI,MAAM,MAAM,EAAE,OAAO,MAAM,KAAG,MAAsC,CAAA;AAE9F;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,GAAI,MAAM,MAAM,EAAE,OAAO,MAAM,KAAG,MAAsC,CAAA;AAE9F;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,UAAU,GAAI,MAAM,MAAM,EAAE,OAAO,MAAM,EAAE,OAAO,MAAM,EAAE,QAAQ,MAAM,KAAG,MAQvF,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,MAAM,EAAE,QAAQ,MAAM,KAAG,MAAsD,CAAA;AAEjH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,MAAM,GAAI,MAAM,MAAM,EAAE,OAAO,MAAM,EAAE,QAAQ,MAAM,KAAG,MAClB,CAAA;AAEnD;;;;;;;;;GASG;AACH,eAAO,MAAM,IAAI,GAAI,MAAM,MAAM,EAAE,OAAO,MAAM,EAAE,QAAQ,MAAM,KAAG,MAKlE,CAAA"}

package/dist/cjs/internal/elide.js

@@ -0,0 +1,59 @@
+"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 elide_exports = {};
+__export(elide_exports, {
+  head: () => head,
+  headSlice: () => headSlice,
+  middle: () => middle,
+  middleFrom: () => middleFrom,
+  noticeCost: () => noticeCost,
+  tailSlice: () => tailSlice
+});
+module.exports = __toCommonJS(elide_exports);
+var bytes = __toESM(require("./bytes.js"), 1);
+const headSlice = (text, limit) => bytes.headSlice(text, limit);
+const tailSlice = (text, limit) => bytes.tailSlice(text, limit);
+const middleFrom = (text, whole, limit, recall) => {
+  if (whole <= limit) return text;
+  const edge = Math.floor(limit / 2);
+  const head2 = headSlice(text, edge);
+  const tail = tailSlice(text, edge);
+  return `${head2}
+\u2026 ${whole - bytes.size(head2) - bytes.size(tail)} of ${whole} bytes elided from the middle. ${recall} \u2026
+${tail}`;
+};
+const noticeCost = (whole, recall) => bytes.size(middleFrom("", whole, 0, recall));
+const middle = (text, limit, recall) => middleFrom(text, bytes.size(text), limit, recall);
+const head = (text, limit, recall) => {
+  const whole = bytes.size(text);
+  if (whole <= limit) return text;
+  const kept = headSlice(text, limit);
+  return `${kept}\u2026 [+${whole - bytes.size(kept)}b, ${recall}]`;
+};
+//# sourceMappingURL=elide.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/elide.ts"],
+  "sourcesContent": ["/**\n * Honest shortening.\n *\n * Every place this harness puts bytes in front of a model is bounded, and every\n * one of those bounds used to be spelled the same way: slice, append `\u2026`, move\n * on. A model reading that cannot tell a value that ends in an ellipsis from a\n * value that was cut, cannot tell how much it lost, and \u2014 the expensive part \u2014\n * cannot tell how to get the rest back, so it buys the same bytes again. Three\n * of the five most expensive instances of the r90 wave spent real money\n * re-fetching a region the run had already rendered and silently clipped\n * (`pydata__xarray-7229` $0.76, `sphinx-doc__sphinx-8721` $0.36,\n * `pytest-dev__pytest-6197` $0.19).\n *\n * So a shortened value states three things: that it was shortened, how many\n * bytes are missing, and the id that brings them back. The id is a sentence the\n * caller supplies, because only the caller knows whether the thing is a state\n * key (`render`), a settled call (`recall`), or something the model must fetch\n * again.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\n\nimport * as bytes from \"./bytes.ts\"\n\n/**\n * The first `limit` UTF-8 bytes of `text`, stopping before a code point that\n * would cross the bound.\n *\n * UTF-8 bytes and UTF-16 indexes do not share boundaries for multibyte text, so\n * a cut may keep fewer bytes than the caller offered. Every bound here is a\n * ceiling: giving bytes back is allowed; taking one is not. Walking by code\n * point also subsumes the surrogate-pair guarantee \u2014 no half of an astral\n * character can survive on either side of a cut.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport const headSlice = (text: string, limit: number): string => bytes.headSlice(text, limit)\n\n/**\n * The last `limit` UTF-8 bytes of `text`, starting on a code-point boundary.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport const tailSlice = (text: string, limit: number): string => bytes.tailSlice(text, limit)\n\n/**\n * Shortens an already-shortened text from the middle, counting against the\n * whole it came from.\n *\n * A value can be bounded twice: once where the host copies it out of the\n * sandbox, and again where the frame apportions its print budget across the\n * statements that share it. Counting the second reduction against what survived\n * the first would report a value as smaller than it is \u2014 the exact dishonesty\n * this module exists to abolish \u2014 so `whole` is stated by the caller, which is\n * the only place that still knows it, and the notice always names the original\n * size.\n *\n * `text` must be the head and tail of the original, in order: every reduction\n * here keeps both ends, so slicing the ends of a reduced value is the same as\n * slicing the ends of the value it came from.\n *\n * The count is what the two ends actually left behind rather than `whole -\n * limit`, because a cut that stopped before a multibyte code point can keep\n * fewer bytes than the limit allowed and the notice names the real number.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport const middleFrom = (text: string, whole: number, limit: number, recall: string): string => {\n  if (whole <= limit) return text\n  const edge = Math.floor(limit / 2)\n  const head = headSlice(text, edge)\n  const tail = tailSlice(text, edge)\n  return `${head}\\n\u2026 ${\n    whole - bytes.size(head) - bytes.size(tail)\n  } of ${whole} bytes elided from the middle. ${recall} \u2026\\n${tail}`\n}\n\n/**\n * The most one {@link middleFrom} notice can cost, for a value of this size.\n *\n * A caller apportioning one budget across several values has to reserve the\n * notices before it can hand out the rest, or it hands out bytes the notices\n * then take back and something downstream cuts the notice in half. The bound is\n * exact: the dropped count is never larger than the whole, so the notice for a\n * value shortened to nothing is the longest notice that value can produce.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport const noticeCost = (whole: number, recall: string): number => bytes.size(middleFrom(\"\", whole, 0, recall))\n\n/**\n * Shortens text from the middle, keeping both ends.\n *\n * The two ends are where a file excerpt, a diff, or a test log identifies\n * itself; the middle is where the repetition is. `recall` is the sentence that\n * says how to see what was dropped.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport const middle = (text: string, limit: number, recall: string): string =>\n  middleFrom(text, bytes.size(text), limit, recall)\n\n/**\n * Shortens text from the end, keeping the head.\n *\n * Used for the one-line summaries a ledger prints, where the head is the whole\n * of what identifies the line and the tail is detail.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport const head = (text: string, limit: number, recall: string): string => {\n  const whole = bytes.size(text)\n  if (whole <= limit) return text\n  const kept = headSlice(text, limit)\n  return `${kept}\u2026 [+${whole - bytes.size(kept)}b, ${recall}]`\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAwBA,YAAuB;AAgBhB,MAAM,YAAY,CAAC,MAAc,UAA0B,MAAM,UAAU,MAAM,KAAK;AAStF,MAAM,YAAY,CAAC,MAAc,UAA0B,MAAM,UAAU,MAAM,KAAK;AA0BtF,MAAM,aAAa,CAAC,MAAc,OAAe,OAAe,WAA2B;AAChG,MAAI,SAAS,MAAO,QAAO;AAC3B,QAAM,OAAO,KAAK,MAAM,QAAQ,CAAC;AACjC,QAAMA,QAAO,UAAU,MAAM,IAAI;AACjC,QAAM,OAAO,UAAU,MAAM,IAAI;AACjC,SAAO,GAAGA,KAAI;AAAA,SACZ,QAAQ,MAAM,KAAKA,KAAI,IAAI,MAAM,KAAK,IAAI,CAC5C,OAAO,KAAK,kCAAkC,MAAM;AAAA,EAAO,IAAI;AACjE;AAeO,MAAM,aAAa,CAAC,OAAe,WAA2B,MAAM,KAAK,WAAW,IAAI,OAAO,GAAG,MAAM,CAAC;AAazG,MAAM,SAAS,CAAC,MAAc,OAAe,WAClD,WAAW,MAAM,MAAM,KAAK,IAAI,GAAG,OAAO,MAAM;AAY3C,MAAM,OAAO,CAAC,MAAc,OAAe,WAA2B;AAC3E,QAAM,QAAQ,MAAM,KAAK,IAAI;AAC7B,MAAI,SAAS,MAAO,QAAO;AAC3B,QAAM,OAAO,UAAU,MAAM,KAAK;AAClC,SAAO,GAAG,IAAI,YAAO,QAAQ,MAAM,KAAK,IAAI,CAAC,MAAM,MAAM;AAC3D;",
+  "names": ["head"]
+}