@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-4IDINPBE.js

@@ -1,525 +0,0 @@
-import {
-  input_fingerprint
-} from "./chunk-GA2YSPFH.js";
-import {
-  git_common_directory
-} from "./chunk-JPMAW2VZ.js";
-import {
-  atomic_write
-} from "./chunk-KSR23NYN.js";
-import {
-  file_reader
-} from "./chunk-ZNX2LJCQ.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/lint/import-graph.ts
-import path2 from "node:path";
-
-// scripts/lint/import-graph-store.ts
-import { existsSync } from "node:fs";
-import path from "node:path";
-import { z } from "zod";
-var STORE_VERSION = 1;
-var STORE_NAME = `import-graph.v${String(STORE_VERSION)}.json`;
-var ENVIRONMENT_FILES = ["package.json", "pnpm-lock.yaml"];
-var EXTENSION = /(?:\.d)?\.[^./]+$/u;
-var INDEX = "index";
-var stored_dependency = z.tuple([z.string(), z.boolean()]);
-var stored_file = z.object({
-  hash: z.string(),
-  all: z.array(stored_dependency).optional(),
-  runtime: z.array(stored_dependency).optional()
-});
-var stored_graph = z.object({
-  version: z.literal(STORE_VERSION),
-  environment: z.string(),
-  files: z.record(z.string(), stored_file)
-});
-function store_path(root) {
-  const common = git_common_directory.repository(root);
-  return common === void 0 ? void 0 : path.join(common, git_common_directory.STATE_DIRECTORY, STORE_NAME);
-}
-function environment_of(root, config_files) {
-  const relatives = [...config_files.map((file) => path.relative(root, file)), ...ENVIRONMENT_FILES];
-  const digests = Object.entries(input_fingerprint.of_files(root, relatives));
-  return input_fingerprint.of_entries(digests.map(([file, digest]) => `${file}:${digest}`));
-}
-function open(root, config_files) {
-  return {
-    root,
-    environment: environment_of(root, config_files),
-    file_path: store_path(root),
-    files: void 0,
-    seeded: /* @__PURE__ */ new Set(),
-    memo: { all: /* @__PURE__ */ new Map(), runtime: /* @__PURE__ */ new Map() },
-    unresolved: { all: /* @__PURE__ */ new Set(), runtime: /* @__PURE__ */ new Set() },
-    content_hashes: /* @__PURE__ */ new Map()
-  };
-}
-function remember(store, name, file, references) {
-  const found = references.filter((dependency) => dependency !== void 0);
-  if (found.length < references.length) store.unresolved[name].add(file);
-  store.memo[name].set(file, found);
-  return found;
-}
-function content_hash(store, file) {
-  const known = store.content_hashes.get(file);
-  if (known !== void 0) return known;
-  const computed = input_fingerprint.of_file(file);
-  store.content_hashes.set(file, computed);
-  return computed;
-}
-function read_files(store) {
-  const text = store.file_path === void 0 ? void 0 : file_reader.read_if_readable(store.file_path);
-  const stored = text === void 0 ? void 0 : json_value.parse_with(text, stored_graph);
-  return stored?.environment === store.environment ? stored.files : {};
-}
-function files_of(store) {
-  store.files ??= read_files(store);
-  return store.files;
-}
-function module_stem(file) {
-  const stem = file.replace(EXTENSION, "");
-  return path.basename(stem) === INDEX ? path.dirname(stem) : stem;
-}
-function added_stems(store, universe) {
-  const files = files_of(store);
-  const added = universe.filter((file) => !Object.hasOwn(files, path.relative(store.root, file)));
-  return new Set(added.map((file) => module_stem(file)));
-}
-function rebased(store, stored) {
-  return stored.map(([file, external]) => ({ file: path.join(store.root, file), external }));
-}
-function is_standing(dependency, seeding) {
-  return existsSync(dependency.file) && !seeding.added.has(module_stem(dependency.file));
-}
-function stored_edges(store, name, file, seeding) {
-  const entry = seeding.files[path.relative(store.root, file)];
-  const stored = entry?.hash === content_hash(store, file) ? entry[name] : void 0;
-  if (stored === void 0) return void 0;
-  const dependencies = rebased(store, stored);
-  return dependencies.every((dependency) => is_standing(dependency, seeding)) ? dependencies : void 0;
-}
-function seed(store, name, universe) {
-  if (store.seeded.has(name)) return [];
-  store.seeded.add(name);
-  const seeding = { files: files_of(store), added: added_stems(store, universe) };
-  const memo = store.memo[name];
-  return universe.filter((file) => {
-    const stored = stored_edges(store, name, file, seeding);
-    if (stored !== void 0 && !memo.has(file)) memo.set(file, stored);
-    return stored === void 0;
-  });
-}
-function entry_of(store, name, file) {
-  const dependencies = store.memo[name].get(file);
-  if (dependencies === void 0 || store.unresolved[name].has(file)) return void 0;
-  const hash = content_hash(store, file);
-  const known = files_of(store)[path.relative(store.root, file)];
-  const entry = known?.hash === hash ? { ...known } : { hash };
-  entry[name] = dependencies.map((dependency) => [
-    path.relative(store.root, dependency.file),
-    dependency.external
-  ]);
-  return entry;
-}
-function write(store, file_path) {
-  const files = Object.entries(files_of(store)).filter(
-    ([file]) => existsSync(path.join(store.root, file))
-  );
-  const graph = {
-    version: STORE_VERSION,
-    environment: store.environment,
-    files: Object.fromEntries(files)
-  };
-  atomic_write.replace_file(file_path, JSON.stringify(graph));
-}
-function keep(store, name, missing) {
-  if (missing.length === 0 || store.file_path === void 0) return;
-  const files = files_of(store);
-  for (const file of missing) {
-    const entry = entry_of(store, name, file);
-    if (entry !== void 0) files[path.relative(store.root, file)] = entry;
-  }
-  write(store, store.file_path);
-}
-var import_graph_store = { content_hash, keep, open, remember, seed, store_path };
-
-// scripts/test/test-inputs.ts
-var GLOBALS = /* @__PURE__ */ new Set([
-  "undefined",
-  "NaN",
-  "Infinity",
-  "Array",
-  "Object",
-  "String",
-  "Number",
-  "Boolean",
-  "BigInt",
-  "Symbol",
-  "Map",
-  "Set",
-  "WeakMap",
-  "WeakSet",
-  "JSON",
-  "RegExp",
-  "Error",
-  "TypeError",
-  "RangeError",
-  "Promise",
-  "parseInt",
-  "parseFloat",
-  "isNaN",
-  "isFinite"
-]);
-var UNSAFE = /* @__PURE__ */ new Set([
-  "process",
-  "global",
-  "globalThis",
-  "eval",
-  "Function",
-  "require",
-  "constructor",
-  "__proto__",
-  "prototype",
-  "vi",
-  "vitest",
-  "inject",
-  "provide",
-  "toMatchSnapshot",
-  "toMatchFileSnapshot",
-  "toThrowErrorMatchingSnapshot",
-  "matchSnapshot"
-]);
-function is_property(typescript, node) {
-  const { parent } = node;
-  return typescript.isPropertyAccessExpression(parent) && parent.name === node || (typescript.isPropertyAssignment(parent) || typescript.isMethodDeclaration(parent)) && parent.name === node;
-}
-function is_unsafe_syntax(typescript, node) {
-  return [
-    typescript.isNamespaceImport(node),
-    typescript.isElementAccessExpression(node),
-    node.kind === typescript.SyntaxKind.ThisKeyword,
-    typescript.isMetaProperty(node)
-  ].includes(true);
-}
-function is_dynamic_import(typescript, node) {
-  return typescript.isCallExpression(node) && node.expression.kind === typescript.SyntaxKind.ImportKeyword;
-}
-function is_unknown_identifier(typescript, node, checker) {
-  if (UNSAFE.has(node.text)) return true;
-  return !is_property(typescript, node) && checker.getSymbolAtLocation(node) === void 0 && !GLOBALS.has(node.text);
-}
-function is_unknown(typescript, node, checker) {
-  if (is_unsafe_syntax(typescript, node) || is_dynamic_import(typescript, node)) return true;
-  if (!typescript.isIdentifier(node)) return false;
-  return is_unknown_identifier(typescript, node, checker);
-}
-function is_closed(typescript, file, content) {
-  const source = typescript.createSourceFile(file, content, typescript.ScriptTarget.Latest, true);
-  const host = typescript.createCompilerHost({});
-  host.getSourceFile = (name) => name === file ? source : void 0;
-  const program = typescript.createProgram([file], { noLib: true, noResolve: true }, host);
-  const checker = program.getTypeChecker();
-  function unknown(node) {
-    if (typescript.isTypeNode(node)) return false;
-    return is_unknown(typescript, node, checker) || typescript.forEachChild(node, unknown) === true;
-  }
-  return program.getSyntacticDiagnostics(source).length === 0 && !unknown(source);
-}
-var test_inputs = { is_closed };
-
-// scripts/lint/type-only-imports.ts
-function declaration_of(typescript, statement) {
-  if (typescript.isImportDeclaration(statement)) return statement;
-  if (typescript.isExportDeclaration(statement)) return statement;
-  return void 0;
-}
-function is_type_only(typescript, declaration) {
-  if (typescript.isExportDeclaration(declaration)) return declaration.isTypeOnly;
-  return declaration.importClause?.phaseModifier === typescript.SyntaxKind.TypeKeyword;
-}
-function type_only_position(typescript, source, statement) {
-  const declaration = declaration_of(typescript, statement);
-  if (declaration === void 0 || !is_type_only(typescript, declaration)) return void 0;
-  const specifier = declaration.moduleSpecifier;
-  if (specifier === void 0 || !typescript.isStringLiteral(specifier)) return void 0;
-  return specifier.getStart(source);
-}
-function runtime_specifiers(typescript, file, content) {
-  const source = typescript.createSourceFile(file, content, typescript.ScriptTarget.Latest);
-  const type_only = new Set(
-    source.statements.map((statement) => type_only_position(typescript, source, statement))
-  );
-  return typescript.preProcessFile(content, true, true).importedFiles.filter((reference) => !type_only.has(reference.pos)).map((reference) => reference.fileName);
-}
-function strings(typescript, file) {
-  const content = file_reader.read_if_readable(file) ?? "";
-  const source = typescript.createSourceFile(file, content, typescript.ScriptTarget.Latest);
-  const found = [];
-  function visit(node) {
-    if (typescript.isStringLiteralLike(node) || typescript.isTemplateLiteralToken(node)) {
-      found.push(node.text);
-    }
-    typescript.forEachChild(node, visit);
-  }
-  visit(source);
-  return found;
-}
-var type_only_imports = { runtime_specifiers, strings };
-
-// scripts/lint/import-test-inputs.ts
-var DECLARATION_EXTENSION = /\.d\.[cm]?ts$/u;
-var TYPESCRIPT_EXTENSION = /\.[cm]?tsx?$/u;
-var JAVASCRIPT_EXTENSIONS = ["js", "jsx", "mjs", "cjs"];
-function is_runtime_source(typescript, file) {
-  if (DECLARATION_EXTENSION.test(file)) return false;
-  if (!TYPESCRIPT_EXTENSION.test(file)) return true;
-  return JAVASCRIPT_EXTENSIONS.every(
-    (extension) => !typescript.sys.fileExists(file.replace(TYPESCRIPT_EXTENSION, () => `.${extension}`))
-  );
-}
-function dependencies_of(typescript, resolve, file, content) {
-  const specifiers = type_only_imports.runtime_specifiers(typescript, file, content);
-  const dependencies = specifiers.filter((name) => name !== "vitest").map((name) => name.startsWith(".") ? resolve(name, file) : void 0);
-  if (dependencies.some((dependency) => dependency === void 0 || dependency.external)) {
-    return void 0;
-  }
-  return dependencies.flatMap((dependency) => dependency?.file ?? []);
-}
-function read_source(typescript, resolve, file) {
-  if (!is_runtime_source(typescript, file)) return void 0;
-  const content = file_reader.read_if_readable(file);
-  if (content === void 0 || !test_inputs.is_closed(typescript, file, content)) return void 0;
-  return dependencies_of(typescript, resolve, file, content);
-}
-function unvisited(file, reached, read) {
-  return reached.has(file) ? [] : read(file);
-}
-function closure(file, read) {
-  const reached = /* @__PURE__ */ new Set();
-  const pending = [file];
-  for (let current = pending.pop(); current !== void 0; current = pending.pop()) {
-    const dependencies = unvisited(current, reached, read);
-    if (dependencies === void 0) return void 0;
-    reached.add(current);
-    pending.push(...dependencies);
-  }
-  return [...reached];
-}
-function create(typescript, resolve) {
-  const cache = /* @__PURE__ */ new Map();
-  function read(file) {
-    if (!cache.has(file)) cache.set(file, read_source(typescript, resolve, file));
-    return cache.get(file);
-  }
-  return (file) => closure(file, read);
-}
-var import_test_inputs2 = { create };
-
-// scripts/lint/import-graph.ts
-var TSCONFIG = "tsconfig.json";
-var NODE_MODULES = "node_modules";
-var MODULE_STATEMENT = /^(?:import|export)\b/mu;
-var GLOBAL_DECLARATION = /^declare (?:global|module|namespace)\b/mu;
-async function load_typescript() {
-  try {
-    const module = await import("typescript");
-    return module.default;
-  } catch {
-    return void 0;
-  }
-}
-function parsed_config(typescript, root) {
-  const config_file = path2.join(root, TSCONFIG);
-  if (!typescript.sys.fileExists(config_file)) return void 0;
-  const source = typescript.readJsonConfigFile(config_file, typescript.sys.readFile);
-  const parsed = typescript.parseJsonSourceFileConfigFileContent(
-    source,
-    typescript.sys,
-    root,
-    void 0,
-    config_file
-  );
-  return {
-    options: parsed.options,
-    file_names: parsed.fileNames,
-    config_files: [config_file, ...source.extendedSourceFiles ?? []]
-  };
-}
-function is_installed(file) {
-  return file.split(path2.sep).includes(NODE_MODULES);
-}
-function as_dependency(file, external) {
-  if (file === void 0) return void 0;
-  return { file, external: external === true && is_installed(file) };
-}
-function relative_to(specifier, file) {
-  return { file: path2.resolve(path2.dirname(file), specifier), external: false };
-}
-function resolve_module(context, specifier, file) {
-  const { typescript, options, resolution_cache } = context;
-  const resolved = typescript.resolveModuleName(
-    specifier,
-    file,
-    options,
-    typescript.sys,
-    resolution_cache
-  ).resolvedModule;
-  if (resolved !== void 0) {
-    return as_dependency(resolved.resolvedFileName, resolved.isExternalLibraryImport);
-  }
-  if (!specifier.startsWith(".")) return void 0;
-  return relative_to(specifier, file);
-}
-function resolve_type(resolver, name, file) {
-  const { typescript, options } = resolver;
-  const resolved = typescript.resolveTypeReferenceDirective(
-    name,
-    file,
-    options,
-    typescript.sys
-  ).resolvedTypeReferenceDirective;
-  return as_dependency(resolved?.resolvedFileName, resolved?.isExternalLibraryImport);
-}
-function references_of(context, file, content) {
-  const processed = context.typescript.preProcessFile(content, true, true);
-  return [
-    ...processed.importedFiles.map(
-      (reference) => resolve_module(context, reference.fileName, file)
-    ),
-    ...processed.referencedFiles.map((reference) => relative_to(reference.fileName, file)),
-    ...processed.typeReferenceDirectives.map(
-      (reference) => resolve_type(context, reference.fileName, file)
-    )
-  ];
-}
-function direct_dependencies(context, file) {
-  const known = context.store.memo.all.get(file);
-  if (known !== void 0) return known;
-  const references = references_of(context, file, file_reader.read_if_readable(file) ?? "");
-  return import_graph_store.remember(context.store, "all", file, references);
-}
-function runtime_dependencies(context, file) {
-  const known = context.store.memo.runtime.get(file);
-  if (known !== void 0) return known;
-  const content = file_reader.read_if_readable(file) ?? "";
-  const references = type_only_imports.runtime_specifiers(context.typescript, file, content).map((specifier) => resolve_module(context, specifier, file));
-  return import_graph_store.remember(context.store, "runtime", file, references);
-}
-function is_ambient(file) {
-  const content = file_reader.read_if_readable(file) ?? "";
-  return GLOBAL_DECLARATION.test(content) || !MODULE_STATEMENT.test(content);
-}
-function ambient_of(resolver, root, config) {
-  const config_file = path2.join(root, TSCONFIG);
-  const declarations = [
-    ...config.file_names.filter((file) => is_ambient(file)),
-    ...config.config_files
-  ].map((file) => ({ file, external: false }));
-  const types = resolver.typescript.getAutomaticTypeDirectiveNames(resolver.options, resolver.typescript.sys).map((name) => resolve_type(resolver, name, config_file)).filter((dependency) => dependency !== void 0);
-  return [...declarations, ...types];
-}
-function is_unvisited(dependency, start, reached) {
-  return dependency.file !== start && !reached.has(dependency.file);
-}
-function join(dependencies, start, reached) {
-  const next = dependencies.filter((dependency) => is_unvisited(dependency, start, reached));
-  for (const dependency of next) reached.set(dependency.file, dependency);
-  return next.filter((dependency) => !dependency.external).map((dependency) => dependency.file);
-}
-function reachable(context, file) {
-  const reached = /* @__PURE__ */ new Map();
-  const pending = [file, ...join(context.ambient, file, reached)];
-  for (let current = pending.pop(); current !== void 0; current = pending.pop()) {
-    pending.push(...join(direct_dependencies(context, current), file, reached));
-  }
-  return reached;
-}
-function token_of(context, dependency) {
-  const name = path2.relative(context.root, dependency.file);
-  if (dependency.external) return name;
-  return `${name}:${import_graph_store.content_hash(context.store, dependency.file)}`;
-}
-function closure_hash(context, file) {
-  const tokens = [...reachable(context, file).values()].map(
-    (dependency) => token_of(context, dependency)
-  );
-  return input_fingerprint.of_entries(tokens);
-}
-function closure2(context, file) {
-  return [...reachable(context, file).values()].filter((dependency) => !dependency.external).map((dependency) => dependency.file);
-}
-function imports(context, file, content) {
-  const dependencies = content === void 0 ? direct_dependencies(context, file) : references_of(context, file, content).filter((dependency) => dependency !== void 0);
-  return dependencies.filter((dependency) => !dependency.external).map((dependency) => dependency.file);
-}
-function append(map, key, value) {
-  const known = map.get(key);
-  if (known === void 0) map.set(key, [value]);
-  else known.push(value);
-}
-function reverse_edges(context, universe, edges) {
-  const reverse = /* @__PURE__ */ new Map();
-  const missing = import_graph_store.seed(context.store, edges.name, universe);
-  for (const file of universe) {
-    for (const dependency of edges.of(context, file)) {
-      append(reverse, dependency.file, file);
-    }
-  }
-  import_graph_store.keep(context.store, edges.name, missing);
-  return reverse;
-}
-function importers(context, files, universe, edges) {
-  const reverse = reverse_edges(context, universe, edges);
-  const reached = new Set(files);
-  const pending = [...files];
-  for (let current = pending.pop(); current !== void 0; current = pending.pop()) {
-    const next = (reverse.get(current) ?? []).filter((file) => !reached.has(file));
-    for (const file of next) reached.add(file);
-    pending.push(...next);
-  }
-  return reached;
-}
-function project_module(context, specifier, file) {
-  const dependency = resolve_module(context, specifier, file);
-  if (dependency === void 0) return void 0;
-  const relative = path2.relative(context.root, dependency.file);
-  return relative.startsWith(`..${path2.sep}`) || path2.isAbsolute(relative) ? void 0 : dependency;
-}
-function graph_of(context) {
-  return {
-    // Type-checker suffixes need not select the source the runner executes.
-    test_inputs: context.options.moduleSuffixes === void 0 ? import_test_inputs2.create(
-      context.typescript,
-      (specifier, file) => project_module(context, specifier, file)
-    ) : void 0,
-    closure: (file) => closure2(context, file),
-    closure_hash: (file) => closure_hash(context, file),
-    imports: (file, content) => imports(context, file, content),
-    importers: (files, universe) => importers(context, files, universe, { name: "all", of: direct_dependencies }),
-    runtime_importers: (files, universe) => importers(context, files, universe, { name: "runtime", of: runtime_dependencies }),
-    strings: (file) => type_only_imports.strings(context.typescript, file)
-  };
-}
-async function create2(root) {
-  const typescript = await load_typescript();
-  if (typescript === void 0) return void 0;
-  const parsed = parsed_config(typescript, root);
-  if (parsed === void 0) return void 0;
-  return graph_of({
-    root,
-    typescript,
-    options: parsed.options,
-    resolution_cache: typescript.createModuleResolutionCache(root, (name) => name, parsed.options),
-    ambient: ambient_of({ typescript, options: parsed.options }, root, parsed),
-    store: import_graph_store.open(root, parsed.config_files)
-  });
-}
-var import_graph = { create: create2 };
-
-export {
-  import_graph
-};

package/dist/commands/chunk-4NSIW3UB.js

@@ -1,104 +0,0 @@
-import {
-  observation_ledger_home
-} from "./chunk-QXBOECGL.js";
-import {
-  git_branch
-} from "./chunk-YEQFAEVW.js";
-import {
-  time_transcript_line
-} from "./chunk-YSLGWRQN.js";
-import {
-  hook_context
-} from "./chunk-CUWT6UQO.js";
-import {
-  agent_session_role
-} from "./chunk-DURHGVRC.js";
-import {
-  git_common_directory
-} from "./chunk-JPMAW2VZ.js";
-import {
-  git_spawn
-} from "./chunk-B5HP6T4L.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/hooks/hook-ledger.ts
-import { appendFile, mkdir } from "node:fs/promises";
-import path from "node:path";
-import { z } from "zod";
-var LEDGER_DIRECTORY = "hook-ledger";
-var LEDGER_EXTENSION = ".jsonl";
-var COMMAND_HEAD = 80;
-var RULE_HEAD = 48;
-var STOP_TOOL = "Stop";
-var COMMAND_FIELDS = ["command", "file_path", "pattern", "url", "prompt"];
-var input_schema = z.record(z.string(), z.unknown());
-var payload_schema = z.object({
-  tool_name: z.string().catch(STOP_TOOL),
-  tool_input: z.unknown().optional(),
-  transcript_path: z.string().catch("")
-});
-var EMPTY_PAYLOAD = payload_schema.parse({});
-var block_schema = z.object({ decision: z.literal("block"), reason: z.string() });
-function rule_of(reason) {
-  const guard = time_transcript_line.guard_from_refusal(reason);
-  return guard === "" ? reason.trim().slice(0, RULE_HEAD) : guard;
-}
-function command_of(input) {
-  const fields = input_schema.safeParse(input).data ?? {};
-  const value = COMMAND_FIELDS.map((key) => fields[key]).find((field) => typeof field === "string");
-  return typeof value === "string" ? value.slice(0, COMMAND_HEAD) : "";
-}
-function entry_of(refusal, branch, now, environment) {
-  const payload = json_value.parse_with(refusal.raw_payload, payload_schema) ?? EMPTY_PAYLOAD;
-  return {
-    at: now.toISOString(),
-    hook: refusal.hook,
-    rule: rule_of(refusal.reason),
-    tool: payload.tool_name,
-    role: environment[agent_session_role.KEY] ?? "",
-    issue: git_branch.issue_from_branch(branch),
-    session: payload.transcript_path,
-    command: command_of(payload.tool_input)
-  };
-}
-function ledger_directory(context = hook_context.from_process()) {
-  if (context.env["VITEST"] !== void 0) return void 0;
-  const common = git_common_directory.repository(context.cwd);
-  return common === void 0 ? void 0 : path.join(common, git_common_directory.STATE_DIRECTORY, LEDGER_DIRECTORY);
-}
-async function append(entry, directory) {
-  const day = observation_ledger_home.ledger_date(new Date(entry.at));
-  await mkdir(directory, { recursive: true });
-  await appendFile(path.join(directory, `${day}${LEDGER_EXTENSION}`), `${JSON.stringify(entry)}
-`);
-}
-async function record(refusal, directory = ledger_directory(), context = hook_context.from_process()) {
-  if (directory === void 0) return;
-  try {
-    const branch = await git_spawn.read(["-C", context.cwd, "rev-parse", "--abbrev-ref", "HEAD"]);
-    await append(entry_of(refusal, branch, /* @__PURE__ */ new Date(), context.env), directory);
-  } catch {
-  }
-}
-async function record_reason(hook, reason, raw_payload, context = hook_context.from_process()) {
-  if (reason !== void 0) {
-    await record({ hook, reason, raw_payload }, ledger_directory(context), context);
-  }
-}
-function blocked_reason(envelope) {
-  return json_value.parse_with(envelope, block_schema)?.reason;
-}
-var hook_ledger = {
-  blocked_reason,
-  command_of,
-  ledger_directory,
-  record,
-  record_reason,
-  rule_of
-};
-
-export {
-  hook_ledger
-};

package/dist/commands/chunk-4YTKV6WV.js

@@ -1,37 +0,0 @@
-import {
-  run_retrospective
-} from "./chunk-IAB6LCJL.js";
-import {
-  doctor_consumer
-} from "./chunk-S4OZJIXD.js";
-import {
-  find_package_directory
-} from "./chunk-LR22UK5W.js";
-
-// scripts/backlog/backlog-drive-retrospective.ts
-var STOP_VERDICT = "stop";
-var EXHAUSTED_ANSWER = "exhausted";
-var RETROSPECTIVE_REASON = "retrospective";
-function is_owed(carry) {
-  const root = find_package_directory(process.cwd());
-  return run_retrospective.is_owed({
-    is_retrospective_enabled: run_retrospective.is_enabled(),
-    is_lane_child: false,
-    is_retrospective_done: carry.retrospective === true,
-    is_consumer: doctor_consumer.is_kit_consumer(root)
-  });
-}
-function is_drain_owed(read, state, verdict) {
-  return read.verdict === verdict && read.answer === EXHAUSTED_ANSWER && state.in_flight.length === 0 && read.is_retrospective_owed === true;
-}
-async function ran(result, read, ports) {
-  if (result.kind === "end" || !is_drain_owed(read, result.state, STOP_VERDICT)) return result;
-  if (await ports.retrospective()) return result;
-  const end = { reason: RETROSPECTIVE_REASON, token: RETROSPECTIVE_REASON, issue: void 0 };
-  return { kind: "end", end, state: result.state };
-}
-var backlog_drive_retrospective = { is_drain_owed, is_owed, ran };
-
-export {
-  backlog_drive_retrospective
-};