@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-RUCV7UYK.js

@@ -0,0 +1,341 @@
+import {
+  defect_origin_line
+} from "./chunk-ZCWBZOBM.js";
+import {
+  behavior_change_lint
+} from "./chunk-2FD3N3OX.js";
+import {
+  issue_not_before
+} from "./chunk-JUXKVN77.js";
+import {
+  issue_auto_ok
+} from "./chunk-N5YPDLZM.js";
+import {
+  measure_declaration
+} from "./chunk-2GJ3WJVT.js";
+import {
+  size_estimate
+} from "./chunk-IAA73DWD.js";
+import {
+  expected_effect_lint
+} from "./chunk-RETTGONB.js";
+import {
+  issue_priority
+} from "./chunk-FBWNL3UA.js";
+import {
+  cli_body
+} from "./chunk-7IZJ5MG2.js";
+import {
+  issue_bug_label
+} from "./chunk-Z4E7V7YJ.js";
+import {
+  pr_classification
+} from "./chunk-CT773QBI.js";
+import {
+  markdown_section
+} from "./chunk-UYHREBT7.js";
+import {
+  issue_body_keys
+} from "./chunk-4DNAAFF4.js";
+import {
+  BREAKING_CHANGE_LABEL,
+  BUG_LABEL,
+  ENHANCEMENT_LABEL,
+  OTHER_CHANGE_LABEL,
+  has_label_name
+} from "./chunk-QQBMVC5W.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  package_path
+} from "./chunk-3CCGKX7Y.js";
+
+// scripts/issue/aggregation-split.ts
+var CRITERIA_HEADING = issue_body_keys.heading("criteria");
+var BACKGROUND_HEADING = issue_body_keys.heading("background");
+var CRITERION_PREFIX = "- [";
+var RECORDING_WORDS = ["Issue", "\u30B3\u30E1\u30F3\u30C8", "\u8A18\u9332"];
+var SUBJECT_WORDS = ["\u96C6\u8A08", "\u8A08\u6E2C", "before", "\u5909\u66F4\u524D\u5F8C"];
+var ISSUE_REFERENCE = /#\d+/u;
+var IMPLEMENTATION_FILES = 3;
+var REFUSAL = `an acceptance criterion records an aggregation or a measurement as an Issue comment beside an implementation of ${String(IMPLEMENTATION_FILES)}+ files \u2014 file it as a prior Issue (\`--route split\`) and cite its comment under ${BACKGROUND_HEADING} in this one; issue-template.md \u2192 "\`${BACKGROUND_HEADING}\` \u76F4\u4E0B\u306E\u5BA3\u8A00\u3068\u5206\u985E\u30E9\u30D9\u30EB"`;
+function is_aggregation_criterion(line) {
+  const text = line.trim();
+  if (!text.startsWith(CRITERION_PREFIX) || ISSUE_REFERENCE.test(text)) return false;
+  return SUBJECT_WORDS.some((word) => text.includes(word)) && RECORDING_WORDS.every((word) => text.includes(word));
+}
+function has_aggregation_criterion(body) {
+  const criteria = markdown_section.section_lines(body, CRITERIA_HEADING).join("\n");
+  return markdown_section.unfenced_lines(criteria).some((line) => is_aggregation_criterion(line));
+}
+function declares_implementation(body) {
+  return (size_estimate.declared_files(body) ?? 0) >= IMPLEMENTATION_FILES;
+}
+function problems(body) {
+  return has_aggregation_criterion(body) && declares_implementation(body) ? [REFUSAL] : [];
+}
+var aggregation_split = { IMPLEMENTATION_FILES, problems };
+
+// scripts/issue/enforcement-lint.ts
+var ENFORCEMENT_PREFIX = issue_body_keys.prefix("enforcement");
+var MEASUREMENT_PREFIX = issue_body_keys.prefix("measurement");
+var BACKGROUND_HEADING2 = issue_body_keys.heading("background");
+var NONE_VALUE = issue_body_keys.value("none");
+var PLACEHOLDER_PREFIX = "<";
+function is_unnamed(value) {
+  return value === "" || value === NONE_VALUE || value.startsWith(PLACEHOLDER_PREFIX);
+}
+function declaration_problem(body, prefix, guide) {
+  const value = measure_declaration.background_value(body, prefix);
+  if (value === void 0) {
+    return `missing declaration under ${BACKGROUND_HEADING2}:\`${prefix} ${guide}\``;
+  }
+  return is_unnamed(value) ? `\`${prefix}\` must name ${guide}, not \`${value}\`` : void 0;
+}
+function problems2(body) {
+  if (!behavior_change_lint.is_target(body)) return [];
+  return [
+    declaration_problem(
+      body,
+      ENFORCEMENT_PREFIX,
+      "<the hook, lint or gate that stops it> or \u8A08\u6E2C\u306E\u307F"
+    ),
+    declaration_problem(body, MEASUREMENT_PREFIX, "<the number a violation shows in (command)>")
+  ].filter((problem) => problem !== void 0);
+}
+var enforcement_lint = { problems: problems2 };
+
+// scripts/issue/figure-source-lint.ts
+var BACKGROUND_HEADING3 = issue_body_keys.heading("background");
+var EFFECT_HEADING = issue_body_keys.heading("expected_effect");
+var PREDICTION = "\u4E88\u6E2C";
+var COMMAND = /`[^`\s]+\s[^`]*`/u;
+var WARNING = `number with no source (add the command that measured it in backticks, or write ${PREDICTION}): `;
+var NOT_A_FIGURE = /#\d+|\d{4}-\d{2}-\d{2}|^\d+\.\s/gu;
+var DIGIT = /\d/u;
+var DECLARATIONS = [
+  "size",
+  "cause_lane",
+  "cause_loss",
+  "priority",
+  "sample_gate",
+  "not_before",
+  "measure_absent",
+  "measurement",
+  "decision_rule"
+].map((key) => issue_body_keys.prefix(key));
+function text_lines(body, heading) {
+  const section2 = markdown_section.section_lines(body, heading).join("\n");
+  return markdown_section.unfenced_lines(section2).map((line) => line.trim());
+}
+function has_no_source(line) {
+  if (COMMAND.test(line) || line.includes(PREDICTION)) return false;
+  return DIGIT.test(line.replaceAll(NOT_A_FIGURE, ""));
+}
+function warnings(body) {
+  const background = text_lines(body, BACKGROUND_HEADING3).filter(
+    (line) => DECLARATIONS.every((prefix) => !line.startsWith(prefix))
+  );
+  return [...background, ...text_lines(body, EFFECT_HEADING)].filter((line) => has_no_source(line)).map((line) => `${WARNING}${line}`);
+}
+var figure_source_lint = { warnings };
+
+// scripts/issue/issue-classification.ts
+var BACKGROUND_HEADING4 = issue_body_keys.heading("background");
+var FEATURE_DECLARATIONS = [
+  issue_body_keys.line("purpose", "feature"),
+  issue_body_keys.line("purpose", "improvement"),
+  issue_body_keys.line("purpose", "time_saving")
+];
+var BREAKING_DECLARATION = issue_body_keys.line("compatibility", "breaking");
+var NON_BUG_DECLARATION = issue_body_keys.line("kind", "non_bug");
+var NON_BUG_LINE = new RegExp(
+  String.raw`^ {0,3}(?:${issue_body_keys.line_variants("kind", "non_bug").join("|")})[ \t]*$`,
+  "mu"
+);
+var CLASSIFICATION_LABELS = [BUG_LABEL, ENHANCEMENT_LABEL, BREAKING_CHANGE_LABEL];
+var CONFLICT = "bug and enhancement declarations cannot be combined";
+var MISSING_BUG_CLASSIFICATION = "missing bug classification";
+var CONFLICTING_BUG_CLASSIFICATIONS = "conflicting bug classifications";
+function required_labels(body) {
+  const labels = [];
+  const background = markdown_section.section_lines(body, BACKGROUND_HEADING4).join("\n");
+  if (issue_bug_label.is_bug_fix(body)) labels.push(BUG_LABEL);
+  if (FEATURE_DECLARATIONS.some((line) => markdown_section.has_unfenced_line(background, line))) {
+    labels.push(ENHANCEMENT_LABEL);
+  }
+  if (markdown_section.has_unfenced_line(background, BREAKING_DECLARATION)) {
+    labels.push(BREAKING_CHANGE_LABEL);
+  }
+  return labels;
+}
+function labels_for(body, existing) {
+  const missing = required_labels(body).filter((label) => !has_label_name(existing, label));
+  return [...existing, ...missing];
+}
+function bug_classification_problem(body) {
+  const background = markdown_section.section_lines(body, BACKGROUND_HEADING4).join("\n");
+  const has_bug = issue_bug_label.is_bug_fix(body);
+  const has_non_bug = markdown_section.has_unfenced_line(background, NON_BUG_DECLARATION);
+  if (!has_bug && !has_non_bug) return MISSING_BUG_CLASSIFICATION;
+  if (has_bug && has_non_bug) return CONFLICTING_BUG_CLASSIFICATIONS;
+  return void 0;
+}
+function label_conflict(body) {
+  const labels = required_labels(body);
+  return labels.includes(BUG_LABEL) && labels.includes(ENHANCEMENT_LABEL) ? CONFLICT : void 0;
+}
+function selection_problem(body, labels) {
+  try {
+    pr_classification.select_classification(labels, body);
+    return void 0;
+  } catch (error) {
+    return error_text.message_of(error);
+  }
+}
+function with_release_classification(body, labels = required_labels(body)) {
+  const line = pr_classification.declaration(OTHER_CHANGE_LABEL);
+  const amended = body.replace(NON_BUG_LINE, (non_bug) => `${non_bug}
+${line}`);
+  if (selection_problem(body, labels) === void 0) return body;
+  return selection_problem(amended, labels) === void 0 ? amended : body;
+}
+function release_problem(body, labels) {
+  if (bug_classification_problem(body) !== void 0 || label_conflict(body) !== void 0) {
+    return void 0;
+  }
+  return selection_problem(with_release_classification(body, labels), labels);
+}
+function problems3(body, labels = required_labels(body)) {
+  const found = [
+    bug_classification_problem(body),
+    label_conflict(body),
+    release_problem(body, labels),
+    defect_origin_line.problem(body),
+    defect_origin_line.reproduction_problem(body)
+  ];
+  return found.filter((problem) => problem !== void 0);
+}
+var issue_classification = {
+  CLASSIFICATION_LABELS,
+  labels_for,
+  problems: problems3,
+  required_labels,
+  with_release_classification
+};
+
+// scripts/issue/issue-lint.ts
+var REQUIRED_HEADINGS = ["background", "symptom", "expected", "criteria"].map((name) => issue_body_keys.heading(name));
+function missing_headings(body) {
+  return REQUIRED_HEADINGS.filter((heading) => !markdown_section.has_line(body, heading));
+}
+function summary_heading() {
+  return issue_body_keys.heading("summary");
+}
+function starts_with_summary(body) {
+  const first = markdown_section.canonical_lines(body).find((line) => line.trim() !== "");
+  return first?.trim() === summary_heading();
+}
+var issue_lint = {
+  missing_headings,
+  REQUIRED_HEADINGS,
+  starts_with_summary,
+  summary_heading
+};
+
+// scripts/issue/issue-template-section.ts
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+var TEMPLATE_PATHS = {
+  ja: "prompts/collaboration-workflow/issue-template.md",
+  en: "prompts/collaboration-workflow/issue-template.en.md"
+};
+var TEMPLATE_FENCE = "````";
+function template_lines(document) {
+  const lines = markdown_section.lines_of(document);
+  const start = lines.findIndex((line) => line.startsWith(TEMPLATE_FENCE));
+  const end = lines.findIndex((line, index) => index > start && line.trim() === TEMPLATE_FENCE);
+  if (start === -1 || end === -1) return [];
+  return lines.slice(start + 1, end);
+}
+function section_of(document, heading) {
+  const template = template_lines(document).join("\n");
+  if (!markdown_section.has_line(template, heading)) return void 0;
+  return [heading, ...markdown_section.section_lines(template, heading)].join("\n").trimEnd();
+}
+function document_name() {
+  return path.basename(TEMPLATE_PATHS[issue_body_keys.column()]);
+}
+function section(heading) {
+  const template_path = package_path(TEMPLATE_PATHS[issue_body_keys.column()]);
+  if (!existsSync(template_path)) return void 0;
+  return section_of(readFileSync(template_path, "utf8"), heading);
+}
+var issue_template_section = { document_name, section, section_of };
+
+// scripts/issue/issue-lint-cli.ts
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+var OK_MESSAGE = "ok";
+var NO_LABELS = "none";
+var USAGE = "Usage: josh issue:lint <path-to-issue-body>";
+var MISSING_HEADING_PREFIX = "missing heading: ";
+function with_template(problem) {
+  if (!problem.startsWith(MISSING_HEADING_PREFIX)) return problem;
+  const template = issue_template_section.section(problem.slice(MISSING_HEADING_PREFIX.length));
+  return template === void 0 ? problem : `${problem}
+${template}`;
+}
+function problems4(body, labels) {
+  const missing = issue_lint.missing_headings(body).map((heading) => `${MISSING_HEADING_PREFIX}${heading}`);
+  return [
+    ...missing,
+    ...behavior_change_lint.problems(body),
+    ...enforcement_lint.problems(body),
+    ...expected_effect_lint.problems(body),
+    ...issue_classification.problems(body, labels),
+    ...issue_not_before.problems(body),
+    ...measure_declaration.problems(body),
+    ...size_estimate.problems(body),
+    ...aggregation_split.problems(body),
+    issue_auto_ok.decision_problem(body),
+    issue_priority.order_problem(body)
+  ].filter((problem) => problem !== void 0).map((problem) => with_template(problem));
+}
+function summary_problem(body) {
+  if (issue_lint.starts_with_summary(body)) return void 0;
+  const heading = issue_lint.summary_heading();
+  const problem = `the body must start with ${heading}: a plain-language summary for a person deciding on the Issue \u2014 how to write it: the ${heading} section of ${issue_template_section.document_name()}'s template`;
+  const template = issue_template_section.section(heading);
+  return template === void 0 ? problem : `${problem}
+${template}`;
+}
+function warn(body) {
+  for (const warning of figure_source_lint.warnings(body)) console.warn(`\u26A0 ${warning}`);
+}
+function report(found, body) {
+  warn(body);
+  if (found.length === 0) {
+    console.info(OK_MESSAGE);
+    console.info(`labels: ${issue_classification.required_labels(body).join(", ") || NO_LABELS}`);
+    return SUCCESS_EXIT_CODE;
+  }
+  console.error(found.map((problem) => `\u2716 ${problem}`).join("\n"));
+  return FAILURE_EXIT_CODE;
+}
+async function run(body_path) {
+  if (body_path === void 0) {
+    console.error(USAGE);
+    return FAILURE_EXIT_CODE;
+  }
+  const body = cli_body.read_file_or_stdin(body_path);
+  const summary = summary_problem(body);
+  return report(summary === void 0 ? problems4(body) : [summary, ...problems4(body)], body);
+}
+var issue_lint_cli = { problems: problems4, run, summary_problem, warn };
+
+export {
+  issue_classification,
+  issue_lint_cli
+};

package/dist/commands/chunk-RVFE7JDZ.js

@@ -0,0 +1,126 @@
+import {
+  epic_graph
+} from "./chunk-3RIQ36LH.js";
+import {
+  markdown_section
+} from "./chunk-UYHREBT7.js";
+import {
+  issue_body_keys
+} from "./chunk-4DNAAFF4.js";
+import {
+  issue_citation
+} from "./chunk-22DVQCP6.js";
+
+// scripts/epic/epic-audit.ts
+var REFERENCE_PATTERN = /#(\d+)\b/gu;
+var PREFIX_CHARACTER = /[\w./-]/u;
+var REPO_SEPARATOR = "/";
+var REPO_PART_COUNT = 2;
+var REPO_NAME_DOT = ".";
+var NO_KNOWN_REPOS = /* @__PURE__ */ new Set();
+var ACCEPTANCE_HEADINGS = /* @__PURE__ */ new Set([
+  issue_body_keys.heading("criteria"),
+  "## Acceptance criteria"
+]);
+function prefix_before(text, index) {
+  let start = index;
+  while (start > 0 && PREFIX_CHARACTER.test(text[start - 1] ?? "")) start -= 1;
+  return text.slice(start, index);
+}
+function is_repo_shape(parts) {
+  return parts.length === REPO_PART_COUNT && parts.every((part) => part !== "");
+}
+function reference_repo(prefix, repo, known) {
+  if (prefix === "") return repo;
+  if (!is_repo_shape(prefix.split(REPO_SEPARATOR))) return void 0;
+  if (!prefix.includes(REPO_NAME_DOT)) return prefix;
+  return known.has(prefix) ? prefix : void 0;
+}
+function to_reference(text, match, repo, known) {
+  const issue_number = Number(match[1]);
+  if (!Number.isSafeInteger(issue_number)) return void 0;
+  const named_repo = reference_repo(prefix_before(text, match.index), repo, known);
+  return named_repo === void 0 ? void 0 : { repo: named_repo, number: issue_number };
+}
+function unique_references(references) {
+  const seen = /* @__PURE__ */ new Set();
+  return references.filter((reference) => {
+    const key = epic_graph.key_of(reference);
+    const is_new = !seen.has(key);
+    seen.add(key);
+    return is_new;
+  });
+}
+function parse_issue_references(text, repo, known = NO_KNOWN_REPOS) {
+  const found = [];
+  for (const match of text.matchAll(REFERENCE_PATTERN)) {
+    const reference = to_reference(text, match, repo, known);
+    if (reference !== void 0) found.push(reference);
+  }
+  return unique_references(found);
+}
+function known_repos(children, current_repo) {
+  return /* @__PURE__ */ new Set([current_repo, ...children.map((child) => child.repo)]);
+}
+function parse_references(text, repo = "") {
+  return parse_issue_references(issue_citation.prose_lines(text).join("\n"), repo).filter((reference) => reference.repo === repo).map((reference) => reference.number);
+}
+function is_acceptance_heading(line) {
+  return ACCEPTANCE_HEADINGS.has(line.trim());
+}
+function acceptance_section(body) {
+  if (body === void 0) return "";
+  return markdown_section.section_lines_matching(body, is_acceptance_heading).join("\n");
+}
+var PARENT_MARKERS = ["\u89AA:", "\u89AA\uFF1A", "Parent:", "parent:"];
+function has_parent_marker(line) {
+  return PARENT_MARKERS.some((marker) => line.includes(marker));
+}
+var PARENT_REFERENCE = /(?:親|Parent|parent)\**[:：]\**\s*(?:[\w.-]+\/[\w.-]+)?#\d+/gu;
+function parent_references(body) {
+  return issue_citation.prose_lines(body).flatMap((line) => [...line.matchAll(PARENT_REFERENCE)].map((match) => match[0])).join("\n");
+}
+function references_in(text, repo, section) {
+  return parse_references(text, repo).map((number) => ({ number, section }));
+}
+function signal_references(body, repo = "") {
+  const read = [
+    ...references_in(acceptance_section(body), repo, "acceptance criteria"),
+    ...references_in(parent_references(body), repo, "parent line")
+  ];
+  return read.filter((reference, index) => {
+    return read.findIndex((other) => other.number === reference.number) === index;
+  });
+}
+function collect_blockers(index, node) {
+  const seen = /* @__PURE__ */ new Set();
+  const pending = [...epic_graph.blockers_of(index, node)];
+  while (pending.length > 0) {
+    const current = pending.pop() ?? node;
+    if (seen.has(current)) {
+      continue;
+    }
+    seen.add(current);
+    pending.push(...epic_graph.blockers_of(index, current));
+  }
+  return seen;
+}
+function depends_on(index, node, target) {
+  return collect_blockers(index, epic_graph.key_of(node)).has(epic_graph.key_of(target));
+}
+var epic_audit_logic = {
+  unique_references,
+  known_repos,
+  parse_issue_references,
+  parse_references,
+  parent_references,
+  acceptance_section,
+  is_acceptance_heading,
+  signal_references,
+  has_parent_marker,
+  depends_on
+};
+
+export {
+  epic_audit_logic
+};

package/dist/commands/chunk-RVKFX3FD.js

@@ -0,0 +1,70 @@
+import {
+  run_merge_token
+} from "./chunk-TBIX42IT.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/run/merge/run-merge-driver.ts
+import { z } from "zod";
+
+// scripts/run/merge/run-merge-outcome.ts
+var CHILD_OUTCOMES = [
+  "merged",
+  "withdrawn",
+  "yielded",
+  "human-review",
+  "parked",
+  "split",
+  "cut",
+  "outage",
+  "unauthenticated",
+  "usage-limit",
+  "failed",
+  "unresolved",
+  "shipping"
+];
+var run_merge_outcome = { CHILD_OUTCOMES };
+
+// scripts/run/merge/run-merge-driver.ts
+var COMMAND = "run:merge";
+var DRIVER_FLAG = "--driver";
+var JSON_KEY = "merge";
+var LINE_BREAK = "\n";
+var DEFERRED_OFFER = "deferred";
+var control_schema = z.object({
+  token: z.enum(Object.values(run_merge_token.MERGE_TOKEN)),
+  code: z.number(),
+  is_offer: z.literal(false),
+  outcome: z.enum(run_merge_outcome.CHILD_OUTCOMES),
+  is_parked: z.boolean().optional()
+});
+var offer_schema = z.object({
+  token: z.string(),
+  code: z.number(),
+  is_offer: z.literal(true),
+  outcome: z.enum(run_merge_outcome.CHILD_OUTCOMES),
+  is_parked: z.boolean().optional()
+});
+var printed_schema = z.object({
+  [JSON_KEY]: z.discriminatedUnion("is_offer", [control_schema, offer_schema])
+});
+function argv_of(merge) {
+  const output = merge.output === void 0 ? [] : ["--output", merge.output];
+  return [COMMAND, merge.child, "--owner", merge.owner, DRIVER_FLAG, ...output];
+}
+function print(result) {
+  return JSON.stringify({ [JSON_KEY]: result });
+}
+function printed(argv, result) {
+  return argv.includes(DRIVER_FLAG) ? print(result) : result.token;
+}
+function read(out) {
+  const last = out.trimEnd().split(LINE_BREAK).at(-1) ?? "";
+  return json_value.parse_with(last, printed_schema)?.[JSON_KEY];
+}
+var run_merge_driver = { DEFERRED_OFFER, DRIVER_FLAG, argv_of, print, printed, read };
+
+export {
+  run_merge_driver
+};

package/dist/commands/chunk-RW7OILP7.js

@@ -0,0 +1,71 @@
+import {
+  run_startup
+} from "./chunk-IZPMBGAI.js";
+import {
+  git_common_directory
+} from "./chunk-MT6TRLFD.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/josh/shared-cache.ts
+import { z } from "zod";
+var record_schema = z.object({
+  key: z.string(),
+  saved_at: z.number(),
+  value: z.unknown()
+});
+function slot_path(slot) {
+  return stamp_file.stamp_path(slot.prefix, git_common_directory.repository() ?? PROJECT_ROOT);
+}
+function is_fresh(saved_at, slot, now_ms) {
+  return saved_at <= now_ms && now_ms - saved_at < slot.ttl_ms;
+}
+function read_value(slot, key, now_ms) {
+  const raw = stamp_file.read_stamp_text(slot_path(slot));
+  const record = raw === void 0 ? void 0 : json_value.parse_with(raw, record_schema);
+  return record?.key === key && is_fresh(record.saved_at, slot, now_ms) ? record.value : void 0;
+}
+function read(slot, key, schema, now_ms) {
+  const parsed = schema.safeParse(read_value(slot, key, now_ms));
+  run_startup.metric(
+    "cache",
+    parsed.success && parsed.data !== void 0 ? "hit" : "miss",
+    `${slot.prefix}:${key}`
+  );
+  return parsed.success ? parsed.data : void 0;
+}
+function write(slot, key, value, now_ms) {
+  try {
+    stamp_file.replace_stamp(slot_path(slot), { key, saved_at: now_ms, value });
+  } catch {
+  }
+}
+async function remember(request, compute, now_ms = Date.now()) {
+  const cached = read(request.slot, request.key, request.schema, now_ms);
+  if (cached !== void 0) return cached;
+  const value = await run_startup.phase(
+    `cache fill ${request.slot.prefix}`,
+    async () => {
+      run_startup.metric("cache", "fill", `${request.slot.prefix}:${request.key}`);
+      return await compute();
+    },
+    { edge_of: (result) => result === void 0 ? "failed" : "done" }
+  );
+  if (value !== void 0) write(request.slot, request.key, value, now_ms);
+  return value;
+}
+function clear(slot) {
+  stamp_file.remove_stamp(slot_path(slot));
+}
+var shared_cache = { clear, read, remember, write };
+
+export {
+  shared_cache
+};