@hraness/wordcell 0.22.5 → 0.23.0

package/dist/{index-de2w8crk.js → index-2fmnttca.js}

@@ -12,35 +12,46 @@ import {
   localizeAssets,
   scoreExtraction,
   sniffImage
-} from "./index-f984hw45.js";
+} from "./index-k86wepd8.js";
 import {
   adapterCapabilities,
   inspectClipEnvironment,
   renderAdapterCapabilities,
   renderDoctorReport
-} from "./index-fc4dr114.js";
+} from "./index-nwrehke7.js";
 import {
   cloneBrowserProfile
 } from "./index-5n05se68.js";
 import {
+  CONFIRM_LINE,
   acquireBrowser,
   acquireCookieHttp,
   acquireCookieRecords,
   acquireFile,
   acquireHttp,
-  assertSafePersistentProfile
-} from "./index-g5vsqmdy.js";
+  assertSafePersistentProfile,
+  cookiePermissionRecovery,
+  renderCookiePermissionNotice,
+  renderCookiePermissionRecovery,
+  setCookiePermissionReporter
+} from "./index-xwxy71ew.js";
 import {
   CONTENT_REWRITE_TRUNCATION_WARNING,
   buildClipMarkdown,
   classifyPlatformUrl,
+  detectAudience,
   parseBlueskyCapture,
   parseHackerNewsCapture,
   parseRedditCapture,
   renderCapturedDocument,
+  renderFailure,
   rewriteContentWithStatus,
-  slugify
-} from "./index-hgve9rh2.js";
+  sentence,
+  slugify,
+  stderrStyle,
+  terminalOutput,
+  writesToTerminal
+} from "./index-cd75vky9.js";
 import {
   MAX_COOKIE_BYTES,
   filterCookieProviderResult,
@@ -61,7 +72,7 @@ import {
   captureUrl,
   parseArguments,
   usage
-} from "./index-dfag79p7.js";
+} from "./index-byz4kzww.js";
 import {
   BoundedByteBuffer
 } from "./index-gh719d91.js";
@@ -2359,10 +2370,10 @@ async function runCapture(rawOptions, dependencies = {}) {
 }
 
 // src/clip/cli.ts
-var defaultOutput = {
+var defaultOutput = terminalOutput({
   stdout: (value) => process.stdout.write(value),
   stderr: (value) => process.stderr.write(value)
-};
+});
 function line(value) {
   return value.endsWith(`
 `) ? value : `${value}
@@ -2378,6 +2389,27 @@ function terminalSafeJson(value) {
   return `${JSON.stringify(value, (_key, candidate) => typeof candidate === "string" ? sanitizeTerminalText(candidate) : candidate, 2)}
 `;
 }
+var CONFIRM_TIMEOUT_MS = 120000;
+async function confirmFromTerminal() {
+  const reader = Bun.stdin.stream().getReader();
+  let timer;
+  try {
+    const timeout = new Promise((resolve2) => {
+      timer = setTimeout(() => resolve2("skip"), CONFIRM_TIMEOUT_MS);
+    });
+    const answer = reader.read().then(({ value }) => {
+      const text = value === undefined ? "" : new TextDecoder().decode(value).trim().toLowerCase();
+      return text === "s" || text === "skip" ? "skip" : "continue";
+    });
+    return await Promise.race([answer, timeout]);
+  } finally {
+    if (timer !== undefined)
+      clearTimeout(timer);
+    await reader.cancel().catch(() => {
+      return;
+    });
+  }
+}
 function captureSummary(outcome) {
   return {
     ok: captureSucceeded(outcome),
@@ -2415,9 +2447,9 @@ async function diagnosticCommand(arguments_, output, inspectEnvironment) {
 async function main(rawArguments = process.argv.slice(2), environment = process.env, output = defaultOutput, dependencies = {}, runtimeOptions = {}) {
   const parsed = parseArguments(rawArguments, environment);
   if (!parsed.ok) {
-    output.stderr(`error: ${safe(parsed.message)}
-
-${sanitizeTerminalText(usage)}`);
+    const first = rawArguments[0];
+    const next = first === "doctor" || first === "adapters" || first === "inspect" ? `wordcell ${first} --help` : "wordcell clip --help";
+    output.stderr(renderFailure(sentence(safe(parsed.message)), next, stderrStyle(environment, output)));
     return 2;
   }
   const arguments_ = parsed.value;
@@ -2432,6 +2464,24 @@ ${sanitizeTerminalText(usage)}`);
     output.stdout(arguments_.json ? terminalSafeJson({ schemaVersion: 1, adapters: adapterCapabilities }) : sanitizeTerminalText(renderAdapterCapabilities()));
     return 0;
   }
+  const onTerminal = dependencies.stderrIsTerminal ?? writesToTerminal(output);
+  const human = !arguments_.json && detectAudience(environment, onTerminal) === "human";
+  let permissionFailure;
+  setCookiePermissionReporter({
+    notice: async (need) => {
+      if (!human || arguments_.quiet)
+        return "continue";
+      output.stderr(renderCookiePermissionNotice(need, environment, stderrStyle(environment, output)));
+      const confirm = dependencies.confirmPermission ?? (onTerminal && process.stdin.isTTY === true ? confirmFromTerminal : undefined);
+      if (confirm === undefined)
+        return "continue";
+      output.stderr(CONFIRM_LINE);
+      return await confirm();
+    },
+    failure: (failure) => {
+      permissionFailure ??= failure;
+    }
+  });
   if (!arguments_.quiet && !arguments_.json) {
     const target = arguments_.currentTab ? "the current browser tab" : safe(arguments_.url?.href ?? "current");
     output.stderr(`Capturing ${target} (${arguments_.mode}, ${arguments_.scope}) ...
@@ -2466,13 +2516,30 @@ ${sanitizeTerminalText(usage)}`);
     }
     return captureExitCode(outcome);
   } catch (error) {
-    const message = safe(error instanceof Error ? error.message : String(error));
+    const raw = error instanceof Error ? error.message : String(error);
+    const recovery = permissionFailure === undefined ? undefined : cookiePermissionRecovery(permissionFailure, environment);
+    if (recovery !== undefined && raw.includes(recovery.message)) {
+      if (arguments_.json) {
+        output.stdout(terminalSafeJson({
+          ok: false,
+          error: recovery.message,
+          code: recovery.code,
+          next: recovery.next,
+          permission: recovery.permission
+        }));
+      } else {
+        output.stderr(renderCookiePermissionRecovery(recovery, stderrStyle(environment, output)));
+      }
+      return 1;
+    }
+    const message = safe(raw);
     if (arguments_.json)
       output.stdout(terminalSafeJson({ ok: false, error: message }));
     else
-      output.stderr(`error: ${message}
-`);
+      output.stderr(renderFailure(message, "wordcell doctor", stderrStyle(environment, output)));
     return 1;
+  } finally {
+    setCookiePermissionReporter(undefined);
   }
 }
 if (import.meta.main)

package/dist/{index-aer0jdrq.js → index-ahyhryb8.js}

@@ -7,7 +7,7 @@ import {
 } from "./index-48pz4jpc.js";
 import {
   lookupNote
-} from "./index-zy7an84p.js";
+} from "./index-jvb7w0gg.js";
 
 // src/search.ts
 var MAX_EXACT_RESULTS = 500;

package/dist/{index-f7fnww7a.js → index-b0khj0h5.js}

@@ -5,9 +5,10 @@ import {
 import {
   isCanonicalNoteId,
   isCanonicalRelationPredicate,
+  isMetadataNumber,
   parseDocumentId,
   parseQualifiedDocumentUri
-} from "./index-zy7an84p.js";
+} from "./index-jvb7w0gg.js";
 
 // src/authoring-model.ts
 import { createHash } from "crypto";
@@ -462,13 +463,159 @@ function renderUpdatedNoteBody(snapshot, parts, body) {
   const header = snapshot.content.slice(0, snapshot.content.length - parts.bodySuffix.length);
   return `${header}${parts.newline}${parts.newline}${normalized}`;
 }
-function renderCreatedNote(input, documentId) {
+var MAX_FRONTMATTER_FIELDS = 64;
+var MAX_FRONTMATTER_LIST_ITEMS = 256;
+var FRONTMATTER_FIELD_KEY = /^[a-z][a-z0-9_]{0,63}$/u;
+var FRONTMATTER_MAP_KEY = /^[A-Za-z0-9_.:-]{1,64}$/u;
+var RESERVED_FRONTMATTER_FIELDS = new Set([
+  "document_id",
+  "type",
+  "title",
+  "tags",
+  "relations"
+]);
+function validateFieldString(value, label) {
+  if (typeof value !== "string")
+    throw new TypeError(`frontmatter field ${label} must be a string`);
+  if (Buffer.from(value, "utf8").toString("utf8") !== value || /[\u0000-\u001f\u007f]/u.test(value)) {
+    throw new TypeError(`frontmatter field ${label} must be a single line of well-formed text`);
+  }
+  return value;
+}
+function validateFieldScalar(value, label) {
+  if (typeof value === "boolean")
+    return value;
+  if (typeof value === "number") {
+    if (!isMetadataNumber(value)) {
+      throw new TypeError(`frontmatter field ${label} must be a finite number and a safe integer when integral`);
+    }
+    return value;
+  }
+  return validateFieldString(value, label);
+}
+function validateFieldValue(value, key) {
+  if (Array.isArray(value)) {
+    if (value.length > MAX_FRONTMATTER_LIST_ITEMS) {
+      throw new TypeError(`frontmatter field ${key} has too many items`);
+    }
+    return value.map((item, index) => validateFieldString(item, `${key}[${index}]`));
+  }
+  if (typeof value === "object" && value !== null) {
+    if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) {
+      throw new TypeError(`frontmatter field ${key} must be a plain map`);
+    }
+    const entries = Object.entries(value);
+    if (entries.length > MAX_FRONTMATTER_FIELDS) {
+      throw new TypeError(`frontmatter field ${key} has too many keys`);
+    }
+    const result = {};
+    for (const [nested, item] of entries) {
+      if (!FRONTMATTER_MAP_KEY.test(nested) || nested === "__proto__") {
+        throw new TypeError(`frontmatter field ${key} has an invalid key: ${JSON.stringify(nested)}`);
+      }
+      result[nested] = validateFieldScalar(item, `${key}.${nested}`);
+    }
+    return result;
+  }
+  return validateFieldScalar(value, key);
+}
+function validateFieldKey(key, allowTitle) {
+  if (!FRONTMATTER_FIELD_KEY.test(key)) {
+    throw new TypeError(`not a valid frontmatter field name: ${JSON.stringify(key)}`);
+  }
+  if (RESERVED_FRONTMATTER_FIELDS.has(key) && !(allowTitle && key === "title")) {
+    throw new TypeError(`frontmatter field ${key} is reserved`);
+  }
+}
+function validateFrontmatterFields(fields) {
+  if (fields === undefined)
+    return {};
+  const entries = Object.entries(fields);
+  if (entries.length > MAX_FRONTMATTER_FIELDS)
+    throw new TypeError("too many frontmatter fields");
+  const result = {};
+  for (const [key, value] of entries) {
+    validateFieldKey(key, false);
+    result[key] = validateFieldValue(value, key);
+  }
+  return result;
+}
+function validateFrontmatterFieldUpdates(fields) {
+  if (fields === undefined)
+    return {};
+  const entries = Object.entries(fields);
+  if (entries.length > MAX_FRONTMATTER_FIELDS)
+    throw new TypeError("too many frontmatter fields");
+  const result = {};
+  for (const [key, value] of entries) {
+    validateFieldKey(key, true);
+    if (key === "title") {
+      if (typeof value !== "string")
+        throw new TypeError("frontmatter field title must be a string");
+      result[key] = validateTitle(value);
+    } else {
+      result[key] = value === null ? null : validateFieldValue(value, key);
+    }
+  }
+  return result;
+}
+function canonicalJson(value) {
+  if (Array.isArray(value))
+    return `[${value.map(canonicalJson).join(",")}]`;
+  if (typeof value === "object" && value !== null) {
+    const keys = Object.keys(value).sort();
+    return `{${keys.map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "undefined";
+}
+function topLevelValue(parts, key) {
+  const contents = parts.document.contents;
+  if (!isMap(contents) || !contents.has(key))
+    return;
+  const node = contents.get(key, true);
+  if (typeof node === "object" && node !== null && "toJSON" in node && typeof node.toJSON === "function") {
+    return node.toJSON();
+  }
+  return node;
+}
+function sameFrontmatterValue(present, requested) {
+  return canonicalJson(present) === canonicalJson(requested);
+}
+function renderUpdatedNoteBodyAndFields(snapshot, parts, body, fields) {
+  const updates = validateFrontmatterFieldUpdates(fields);
+  const bodyOnly = renderUpdatedNoteBody(snapshot, parts, body);
+  if (Object.keys(updates).length === 0)
+    return bodyOnly;
+  if (!parts.hadFrontmatter || !isMap(parts.document.contents)) {
+    throw new TypeError("frontmatter fields require a note with a frontmatter map");
+  }
+  const contents = parts.document.contents;
+  for (const [key, value] of Object.entries(updates)) {
+    if (value === null) {
+      contents.delete(key);
+    } else if (!sameFrontmatterValue(topLevelValue(parts, key), value)) {
+      contents.set(key, parts.document.createNode(value));
+    }
+  }
+  const content = renderFrontmatter({
+    ...parts,
+    bodySuffix: `${parts.newline}${parts.newline}${normalizedRequestedBody(body)}`
+  });
+  if (Buffer.byteLength(content, "utf8") > MAX_NOTE_BYTES) {
+    throw new RangeError("the note is too large for bounded authoring");
+  }
+  return content;
+}
+function renderCreatedNote(input, documentId, fields) {
   const title = validateTitle(input.title);
   const type = validateType(input.type);
   const tags = validateTags(input.tags);
+  const extra = validateFrontmatterFields(fields);
   const metadata = { document_id: documentId, type, title };
   if (tags.length > 0)
     metadata["tags"] = tags;
+  for (const [key, value] of Object.entries(extra))
+    metadata[key] = value;
   const document = new Document(metadata, { schema: "core" });
   const body = normalizedRequestedBody(input.body ?? `# ${title}
 `);
@@ -517,8 +664,9 @@ function existingDocumentId(parts) {
     return { kind: "invalid" };
   }
 }
-function assertCompatibleCreate(snapshot, input, requestedDocumentId) {
+function assertCompatibleCreate(snapshot, input, requestedDocumentId, fields) {
   const parts = frontmatter(snapshot.content, snapshot.relativePath);
+  const requestedFields = validateFrontmatterFields(fields);
   const requestedType = validateType(input.type);
   const requestedTitle = validateTitle(input.title);
   if (topLevelScalar(parts, "type") !== requestedType) {
@@ -535,6 +683,11 @@ function assertCompatibleCreate(snapshot, input, requestedDocumentId) {
   if (input.body !== undefined && parts.bodySuffix !== `${parts.newline}${parts.newline}${normalizedRequestedBody(input.body)}`) {
     throw new NoteAlreadyExistsError(snapshot.relativePath, "body differs");
   }
+  for (const [key, value] of Object.entries(requestedFields)) {
+    if (!sameFrontmatterValue(topLevelValue(parts, key), value)) {
+      throw new NoteAlreadyExistsError(snapshot.relativePath, `${key} differs`);
+    }
+  }
   const existingId = existingDocumentId(parts);
   if (requestedDocumentId !== undefined && (existingId.kind !== "valid" || existingId.documentId !== requestedDocumentId)) {
     throw new NoteAlreadyExistsError(snapshot.relativePath, existingId.kind === "missing" ? "document_id is missing" : "document_id differs");
@@ -1125,10 +1278,11 @@ function installNote(platform, vault, id, content, expected, lock, dependencies)
     }));
   });
 }
-function createNoteProgram(platform, root, input, options) {
+function createNoteProgram(platform, root, input, options, fields) {
   return Effect2.gen(function* () {
     const vault = yield* authoringNative(() => platform.resolveVault(root));
     const id = yield* authoringSync(() => canonicalNoteId(input.id));
+    const extra = yield* authoringSync(() => validateFrontmatterFields(fields));
     const requestedDocumentId = yield* authoringSync(() => input.documentId === undefined ? undefined : parseDocumentId(input.documentId));
     const expected = yield* authoringSync(() => checkedExpectedRevision(options));
     const dependencies = yield* authoringSync(() => platform.dependenciesFor(options.dependencies));
@@ -1137,13 +1291,13 @@ function createNoteProgram(platform, root, input, options) {
       const existing = yield* authoringNative(() => platform.readOptionalSnapshot(vault, id));
       if (existing !== null) {
         yield* authoringSync(() => assertExpected(existing, expected));
-        const compatible = yield* authoringSync(() => assertCompatibleCreate(existing, input, requestedDocumentId));
+        const compatible = yield* authoringSync(() => assertCompatibleCreate(existing, input, requestedDocumentId, extra));
         return yield* authoringSync(() => noteResult(existing, compatible.relations, false, compatible.documentId));
       }
       if (expected !== undefined)
         return yield* fail(new NoteRevisionConflictError(`${id}.md`, expected, null));
       const documentId = yield* authoringSync(() => requestedDocumentId ?? parseDocumentId(dependencies.documentId()));
-      const content = yield* authoringSync(() => renderCreatedNote(input, documentId));
+      const content = yield* authoringSync(() => renderCreatedNote(input, documentId, extra));
       const revision = yield* installNote(platform, vault, id, content, null, lock, dependencies);
       return { changed: true, path: `${id}.md`, revision, relations: [], documentId };
     }), (lock) => authoringNative(() => lock.release()));
@@ -1177,9 +1331,10 @@ function editNoteRelationProgram(platform, operation, root, sourceIdInput, predi
     }), (lock) => authoringNative(() => lock.release()));
   });
 }
-function updateNoteBodyProgram(platform, root, idInput, body, options) {
+function updateNoteBodyProgram(platform, root, idInput, body, options, fields) {
   return Effect2.gen(function* () {
     const id = yield* authoringSync(() => canonicalNoteId(idInput));
+    const updates = yield* authoringSync(() => validateFrontmatterFieldUpdates(fields));
     const expected = yield* authoringSync(() => {
       if (typeof options?.expectedRevision !== "string") {
         throw new TypeError("expectedRevision is required for a note body update");
@@ -1198,7 +1353,7 @@ function updateNoteBodyProgram(platform, root, idInput, body, options) {
         return yield* fail(new TypeError("the note has an invalid document_id"));
       const documentId = identity.kind === "valid" ? identity.documentId : undefined;
       const relations = yield* authoringSync(() => relationsFromParts(parts, source.relativePath));
-      const content = yield* authoringSync(() => renderUpdatedNoteBody(source, parts, body));
+      const content = yield* authoringSync(() => renderUpdatedNoteBodyAndFields(source, parts, body, updates));
       if (content === source.content)
         return yield* authoringSync(() => noteResult(source, relations, false, documentId));
       const revision = yield* installNote(platform, vault, id, content, source, lock, dependencies);
@@ -1237,4 +1392,4 @@ async function removeNoteRelation(root, sourceId, predicate, targetId, options =
   return runAuthoring(editNoteRelationProgram(nativeAuthoringPlatform, "remove", root, sourceId, predicate, targetId, options));
 }
 
-export { InvalidCanonicalNoteIdError, NoteRevisionConflictError, NoteAlreadyExistsError, NoteRecoveryRequiredError, canonicalNoteId, canonicalRelationTarget, normalizeRelationPredicate, noteRevision, listNoteRelations, createNote, createConceptNote, updateNoteBody, addNoteRelation, removeNoteRelation };
+export { MAX_NOTE_BYTES, NOTE_REVISION_PATTERN, InvalidCanonicalNoteIdError, NoteRevisionConflictError, NoteAlreadyExistsError, NoteRecoveryRequiredError, isErrno, sha256, revisionFor, canonicalNoteId, canonicalRelationTarget, normalizeRelationPredicate, frontmatter, relationsFromParts, renderUpdatedNoteBodyAndFields, renderCreatedNote, resolveVault, assertExactDirectoryEntry, assertSafeParent, nativeAuthoringPlatform, runAuthoring, createNoteProgram, updateNoteBodyProgram, noteRevision, listNoteRelations, createNote, createConceptNote, updateNoteBody, addNoteRelation, removeNoteRelation };

package/dist/{index-qdb8f8va.js → index-bdwcjvr4.js}

@@ -5,7 +5,7 @@ import {
   isCanonicalNoteId,
   isCanonicalRelationPredicate,
   lookupNote
-} from "./index-zy7an84p.js";
+} from "./index-jvb7w0gg.js";
 
 // src/percolate.ts
 import { createHash } from "crypto";

package/dist/{index-dfag79p7.js → index-byz4kzww.js}

@@ -345,9 +345,12 @@ Capture options:
   --scope auto|page|thread|comments Content scope (default: platform-aware)
   --html <path|->                  Parse saved/rendered HTML; - reads stdin
   --browser-profile <name|path>    Use a signed-in or persistent Chrome profile
+                                   (downloads read its cookies from the keychain)
   --browser-live                   Attach to a live Chrome session
   --cdp <loopback-port>            Attach to a local CDP-capable browser
   --cookie-source <browser>        chrome|arc|brave|chromium|edge|firefox|safari
+                                   On a Mac, Chromium browsers ask for keychain
+                                   access; Safari needs Full Disk Access
   --cookie-profile <name|path>     Browser profile; Safari expects a Cookies.binarycookies path
   --cookies-file <path>            Cookie-Editor JSON/base64, Netscape, Cookie header, or cURL input
   --media none|images|all          Localize images or all supported media

package/dist/{index-hgve9rh2.js → index-cd75vky9.js}

@@ -3,6 +3,101 @@ import {
   sanitizeTerminalText
 } from "./index-1xxnjn0d.js";
 
+// src/cli-style.ts
+var UNICODE_SYMBOLS = {
+  ok: "\u2713",
+  fail: "\u2717",
+  warn: "\u26A0",
+  next: "\u2192",
+  on: "\u25CF",
+  off: "\u25CB",
+  skip: "\u2013",
+  progress: "\u21BB",
+  notice: "\uD83D\uDD10"
+};
+var ASCII_SYMBOLS = {
+  ok: "OK",
+  fail: "FAIL",
+  warn: "WARN",
+  next: "->",
+  on: "*",
+  off: "o",
+  skip: "-",
+  progress: "...",
+  notice: "NOTE"
+};
+var SYMBOL_COLORS = {
+  ok: "32",
+  fail: "31",
+  warn: "33",
+  next: "2",
+  on: "32",
+  skip: "2"
+};
+function nonEmpty(value) {
+  return value !== undefined && value !== "";
+}
+function prefersAscii(env) {
+  if (env.TERM === "dumb" || env.HRANESS_ASCII === "1")
+    return true;
+  const locale = [env.LC_ALL, env.LC_CTYPE, env.LANG].find(nonEmpty);
+  return locale === undefined || !/utf-?8/iu.test(locale);
+}
+function prefersColor(env, isTTY) {
+  if (env.FORCE_COLOR === "1")
+    return true;
+  if (nonEmpty(env.NO_COLOR))
+    return false;
+  return isTTY && env.TERM !== "dumb";
+}
+function terminalStyle(env, isTTY) {
+  return { ascii: prefersAscii(env), color: prefersColor(env, isTTY) };
+}
+function symbol(name, style) {
+  const glyph = style.ascii ? ASCII_SYMBOLS[name] : UNICODE_SYMBOLS[name];
+  const color = SYMBOL_COLORS[name];
+  return style.color && color !== undefined ? `\x1B[${color}m${glyph}\x1B[0m` : glyph;
+}
+var AGENT_MARKERS = [
+  "AI_AGENT",
+  "CLAUDECODE",
+  "CODEX_SANDBOX",
+  "CODEX_SANDBOX_NETWORK_DISABLED",
+  "CURSOR_AGENT",
+  "GEMINI_CLI"
+];
+function detectAudience(env, stderrIsTTY) {
+  const explicit = env.HRANESS_AUDIENCE;
+  if (explicit === "human" || explicit === "agent" || explicit === "quiet")
+    return explicit;
+  if (explicit === "off")
+    return "quiet";
+  if (AGENT_MARKERS.some((marker) => nonEmpty(env[marker])))
+    return "agent";
+  return stderrIsTTY ? "human" : "quiet";
+}
+function renderFailure(text, next, style) {
+  return `${symbol("fail", style)} ${text}
+${symbol("next", style)} ${next}
+`;
+}
+function sentence(message) {
+  const trimmed = message.trim();
+  const capitalized = /^[a-z]/u.test(trimmed) ? `${trimmed[0]?.toUpperCase() ?? ""}${trimmed.slice(1)}` : trimmed;
+  return /[.!?]$/u.test(capitalized) ? capitalized : `${capitalized}.`;
+}
+var terminalOutputs = new WeakSet;
+function terminalOutput(output) {
+  terminalOutputs.add(output);
+  return output;
+}
+function stderrStyle(env, output) {
+  return terminalStyle(env, terminalOutputs.has(output) && process.stderr.isTTY === true);
+}
+function writesToTerminal(output) {
+  return terminalOutputs.has(output) && process.stderr.isTTY === true;
+}
+
 // src/clip/lib.ts
 var articleMetadataLimits = {
   title: 2048,
@@ -2043,4 +2138,4 @@ function renderCapturedDocument(document) {
   return rewriteContent(markdown, new URL(document.sourceUrl), new Map, { remoteImages: "embed" });
 }
 
-export { articleMetadataLimits, slugify, yamlString, resolveRemote, scanImageSources, CONTENT_REWRITE_TRUNCATION_WARNING, rewriteContentWithStatus, buildClipMarkdown, classifyPlatformUrl, parseHackerNewsCapture, parseRedditCapture, parseBlueskyCapture, renderCapturedDocument };
+export { terminalStyle, symbol, detectAudience, renderFailure, sentence, terminalOutput, stderrStyle, writesToTerminal, articleMetadataLimits, slugify, yamlString, resolveRemote, scanImageSources, CONTENT_REWRITE_TRUNCATION_WARNING, rewriteContentWithStatus, buildClipMarkdown, classifyPlatformUrl, parseHackerNewsCapture, parseRedditCapture, parseBlueskyCapture, renderCapturedDocument };

package/dist/{index-n57tewfr.js → index-fp732bgg.js}

@@ -2,14 +2,14 @@
 import {
   fuseRankedCandidates,
   validateSearchQuery
-} from "./index-aer0jdrq.js";
+} from "./index-ahyhryb8.js";
 import {
   MAX_NOTE_UTF8_BYTES,
   MAX_SCANNED_NOTES,
   MAX_VAULT_UTF8_BYTES,
   VaultScanBudgetError,
   scanVault
-} from "./index-8v6k9h4r.js";
+} from "./index-1s8mc4hz.js";
 
 // src/semantic.ts
 import { createHash as createHash2 } from "crypto";

package/dist/{index-zy7an84p.js → index-jvb7w0gg.js}

@@ -303,12 +303,15 @@ class VaultAnalysisBudgetError extends RangeError {
 function isMetadataObject(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
+function isMetadataNumber(value) {
+  return Number.isFinite(value) && (!Number.isInteger(value) || Number.isSafeInteger(value));
+}
 function parsedMetadataValue(value, ancestors) {
   if (value === null || typeof value === "string" || typeof value === "boolean") {
     return { ok: true, value };
   }
   if (typeof value === "number") {
-    return Number.isFinite(value) && (!Number.isInteger(value) || Number.isSafeInteger(value)) ? { ok: true, value } : { ok: false };
+    return isMetadataNumber(value) ? { ok: true, value } : { ok: false };
   }
   if (typeof value !== "object" || ancestors.has(value))
     return { ok: false };
@@ -1281,4 +1284,4 @@ function replaceCatalog(indexContent, catalog) {
   return indexContent.slice(0, start) + catalog + indexContent.slice(end + catalogEnd.length);
 }
 
-export { MAX_PORTFOLIO_NAME_BYTES, MAX_DOCUMENT_ID_BYTES, portfolioVaultIdentity, parseVaultKey, parseDocumentId, documentIdState, formatQualifiedDocumentUri, parseQualifiedDocumentUri, portfolioDocumentIdentity, catalogStart, catalogEnd, MAX_ANALYZED_NOTES, MAX_CONNECTION_OBSERVATIONS, MAX_MENTION_PAIRS, MAX_MENTIONS, VaultAnalysisBudgetError, metadataValueFromUnknown, isCanonicalRelationPredicate, isCanonicalNoteId, normalizeVaultPath, searchableMarkdown, wikiLinks, parseNote, lookupNote, analyzeVault, analyzeVaultComplete, renderCatalog, replaceCatalog };
+export { MAX_PORTFOLIO_NAME_BYTES, MAX_DOCUMENT_ID_BYTES, portfolioVaultIdentity, parseVaultKey, parseDocumentId, documentIdState, formatQualifiedDocumentUri, parseQualifiedDocumentUri, portfolioDocumentIdentity, catalogStart, catalogEnd, MAX_ANALYZED_NOTES, MAX_CONNECTION_OBSERVATIONS, MAX_MENTION_PAIRS, MAX_MENTIONS, VaultAnalysisBudgetError, isMetadataNumber, metadataValueFromUnknown, isCanonicalRelationPredicate, isCanonicalNoteId, normalizeVaultPath, searchableMarkdown, wikiLinks, parseNote, lookupNote, analyzeVault, analyzeVaultComplete, renderCatalog, replaceCatalog };

package/dist/{index-f984hw45.js → index-k86wepd8.js}

@@ -6,7 +6,7 @@ import {
   resolveRemote,
   rewriteContentWithStatus,
   scanImageSources
-} from "./index-hgve9rh2.js";
+} from "./index-cd75vky9.js";
 import {
   FetchFailure,
   safeFetch

package/dist/{index-1r5rnkfr.js → index-mnq2wy34.js}

@@ -2,7 +2,7 @@
 import {
   MAX_SEARCH_RESULTS,
   openKnowledgeBase
-} from "./index-42tb8qqp.js";
+} from "./index-tvd2sqrx.js";
 import {
   MAX_EVALUATION_EVIDENCE_BYTES,
   redactEvaluationMachinePaths
@@ -12,7 +12,7 @@ import {
 } from "./index-1gwbassd.js";
 import {
   scanVault
-} from "./index-8v6k9h4r.js";
+} from "./index-1s8mc4hz.js";
 import {
   MAX_REPOSITORY_MEMORY_DETAIL_LIMIT,
   MAX_REPOSITORY_MEMORY_GROUP_LIMIT,

package/dist/{index-p96kb6t2.js → index-nn67kzwa.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   fuseRankedCandidates
-} from "./index-aer0jdrq.js";
+} from "./index-ahyhryb8.js";
 
 // src/benchmark.ts
 var MAX_BENCHMARK_CASES = 500;

package/dist/{index-fc4dr114.js → index-nwrehke7.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   isolatedAgentBrowserEnvironment
-} from "./index-g5vsqmdy.js";
+} from "./index-xwxy71ew.js";
 import {
   BoundedByteBuffer
 } from "./index-gh719d91.js";

package/dist/{index-n9kwenpt.js → index-p70t8j13.js}

@@ -4,7 +4,7 @@ import {
 } from "./index-h170byqw.js";
 import {
   packUntrustedSearchContext
-} from "./index-42tb8qqp.js";
+} from "./index-tvd2sqrx.js";
 
 // src/workflows/decision-context.ts
 var decisionContextWorkflow = defineWorkflow({

package/dist/{index-pz2b2x0y.js → index-pgtm2nhf.js}

@@ -5,7 +5,7 @@ import {
 import {
   isCanonicalNoteId,
   isCanonicalRelationPredicate
-} from "./index-zy7an84p.js";
+} from "./index-jvb7w0gg.js";
 
 // src/graph-authority-model.ts
 var GRAPH_LIMITS = Object.freeze({