@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-CXFN5W7O.js

@@ -0,0 +1,116 @@
+import {
+  lane_implement_stats
+} from "./chunk-UWLANGIR.js";
+import {
+  test_declared_logic
+} from "./chunk-7HCPRVMB.js";
+import {
+  delegation_policy
+} from "./chunk-6I2JM5UX.js";
+import {
+  run_event_scope
+} from "./chunk-XO7S2BTY.js";
+import {
+  run_event_stream
+} from "./chunk-373P5MM2.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+
+// scripts/lane/lane-implement-signals.ts
+import path from "node:path";
+var LABEL = "signals";
+var KIND = run_event_stream.EVENT_KIND.LANE_PHASE;
+var PAIR_SEPARATOR = "=";
+var WORD_SEPARATOR = " ";
+var LABEL_INDEX = 1;
+var FIELDS = {
+  edits: "edits",
+  test_related: "test-related",
+  lint_related: "lint-related",
+  investigations: "investigations",
+  unplanned: "unplanned"
+};
+var OUTSIDE_PREFIXES = ["..", ".josh/"];
+var TEST_RELATED = /(?:^|[;&|(]\s*)(?:pnpm )?josh test:related(?![\w:-])/u;
+var LINT_RELATED = /(?:^|[;&|(]\s*)(?:pnpm )?josh lint:related(?![\w:-])/u;
+var EDIT_BAR = 8;
+var RERUN_BAR = 2;
+var INVESTIGATION_BAR = 1;
+var FIELD_ORDER = [
+  "edits",
+  "test_related",
+  "lint_related",
+  "investigations",
+  "unplanned"
+];
+var KEYS = [
+  { field: "unplanned", bar: 0, key: "plan divergence" },
+  { field: "edits", bar: EDIT_BAR, key: "edited files" },
+  { field: "test_related", bar: RERUN_BAR, key: "test:related reruns" },
+  { field: "lint_related", bar: RERUN_BAR, key: "lint:related reruns" },
+  { field: "investigations", bar: INVESTIGATION_BAR, key: "investigation units" }
+];
+function edited_files(calls, root) {
+  const files = calls.filter((call) => lane_implement_stats.EDIT_TOOLS.has(call.tool ?? "")).map((call) => call.file_path).filter((file) => file !== void 0).map((file) => path.relative(root, file));
+  return [...new Set(files)].filter(
+    (file) => OUTSIDE_PREFIXES.every((prefix) => !file.startsWith(prefix))
+  );
+}
+function command_count(calls, pattern) {
+  return calls.filter((call) => pattern.test(call.command ?? "")).length;
+}
+function is_investigator(call) {
+  return call.subagent?.type.split(":").at(-1) === delegation_policy.INVESTIGATOR_AGENT;
+}
+function counts_of(calls, planned, root) {
+  const edits = edited_files(calls, root);
+  const plan = new Set(planned);
+  const outside = edits.filter((file) => !plan.has(file) && !test_declared_logic.is_test_file(file));
+  return {
+    edits: edits.length,
+    test_related: command_count(calls, TEST_RELATED),
+    lint_related: command_count(calls, LINT_RELATED),
+    investigations: calls.filter((call) => is_investigator(call)).length,
+    unplanned: outside.length
+  };
+}
+function text_of(issue, signals) {
+  const pairs = FIELD_ORDER.map(
+    (field) => `${FIELDS[field]}${PAIR_SEPARATOR}${String(signals[field])}`
+  );
+  return [issue_cite.plain_for("program", issue), LABEL, ...pairs].join(WORD_SEPARATOR);
+}
+function is_signals_of(event, issue) {
+  const label = event.text.split(WORD_SEPARATOR)[LABEL_INDEX];
+  return event.kind === KIND && label === LABEL && run_event_scope.issue_named(event) === String(issue);
+}
+function pair_of(word) {
+  const [name = "", value = ""] = word.split(PAIR_SEPARATOR);
+  return [name, value];
+}
+function parse(text) {
+  const pairs = new Map(text.split(WORD_SEPARATOR).map((word) => pair_of(word)));
+  function read(field) {
+    return Number(pairs.get(FIELDS[field]) ?? 0);
+  }
+  return {
+    edits: read("edits"),
+    test_related: read("test_related"),
+    lint_related: read("lint_related"),
+    investigations: read("investigations"),
+    unplanned: read("unplanned")
+  };
+}
+function signals_of(events, issue) {
+  const event = events.findLast((candidate) => is_signals_of(candidate, issue));
+  return event === void 0 ? void 0 : parse(event.text);
+}
+function keys_of(signals) {
+  return KEYS.filter(({ field, bar }) => signals[field] > bar).map(({ key }) => key);
+}
+var lane_implement_signals = { KIND, counts_of, is_signals_of, keys_of, signals_of, text_of };
+
+export {
+  lane_implement_signals
+};

package/dist/commands/chunk-CXVNQ7DS.js

@@ -0,0 +1,88 @@
+import {
+  bash_triggers
+} from "./chunk-25LVQDOF.js";
+import {
+  shell_segments
+} from "./chunk-CVJHQOI3.js";
+import {
+  agent_consultation_model
+} from "./chunk-O5JGV7NA.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/rules/main-model.ts
+import { z } from "zod";
+var SYNTHETIC_MODEL = "<synthetic>";
+var named_model = z.object({ model: z.string() });
+var entry_schema = z.union([
+  z.object({ type: z.literal("assistant"), message: named_model }),
+  z.object({ type: z.literal("turn_context"), payload: named_model })
+]);
+function model_of_line(line) {
+  const entry = json_value.parse_with(line, entry_schema);
+  if (entry === void 0) return void 0;
+  const model = entry.type === "assistant" ? entry.message.model : entry.payload.model;
+  return model === SYNTHETIC_MODEL ? void 0 : model;
+}
+function model_of_tail(tail) {
+  const lines = tail.split("\n");
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const model = model_of_line(lines[index] ?? "");
+    if (model !== void 0) return model;
+  }
+  return void 0;
+}
+function main_model(tail, payload_model, recorded_model) {
+  return payload_model ?? model_of_tail(tail) ?? recorded_model;
+}
+var main_model_reader = { main_model };
+
+// scripts/rules/consultation-handoff.ts
+var HANDOFF_DOC = '`docs/josh-commands-board.md` \u2192 "josh run:handoff"';
+var REASON = `\u26D4 consultation handoff: a consultation-model main line does not enter a run itself. Run \`pnpm josh run:handoff <keyword> \u2026 --brief-file <brief>\` instead of \`run:entry\` / \`run:hold\`; filing and operating (\`issue:file\`, \`issue:plan\`, \`epic\`) stay here. Fires on every occurrence (${HANDOFF_DOC}).`;
+function josh_call_of(names) {
+  const name_set = new Set(names);
+  return function is_josh_call(command) {
+    return shell_segments.segments_of(command).some((segment) => shell_segments.is_josh_command(segment, name_set));
+  };
+}
+var is_entry_call = josh_call_of(["run:entry", "run:hold"]);
+var is_handoff_call = josh_call_of(["run:handoff"]);
+function is_consultation_main(tail, payload_model, recorded_model) {
+  const model = main_model_reader.main_model(tail, payload_model, recorded_model);
+  return model !== void 0 && agent_consultation_model.consultation_provider(model) !== void 0;
+}
+function is_not_consultation_main(tail, _call, run) {
+  if (lane_child_marker.is_child_of(run.context.cwd, run.context.env)) return true;
+  return run.is_unit === true || !is_consultation_main(tail, run.model);
+}
+var ROW = {
+  id: "consultation-handoff",
+  is_trigger: bash_triggers.on_bash_command(is_entry_call),
+  reason: REASON,
+  already_satisfied: is_not_consultation_main,
+  decide: () => true,
+  keeps: bash_triggers.on_bash_command(is_handoff_call),
+  about: {
+    title: "Consultation main line hands a run to run:handoff",
+    topic: HANDOFF_DOC,
+    fires: "`pnpm josh run:entry` / `run:hold` on Fable or Codex Astra. Every occurrence",
+    quiet: "a lane child, a main line on any other model, an unnamed model, a delegated unit, or filing and operating (`issue:file`, `issue:plan`, `epic`)"
+  }
+};
+var consultation_handoff = {
+  HANDOFF_DOC,
+  ROW,
+  is_consultation_main,
+  is_entry_call,
+  is_handoff_call
+};
+
+export {
+  main_model_reader,
+  consultation_handoff
+};

package/dist/commands/chunk-CYYJLRIW.js

@@ -0,0 +1,85 @@
+import {
+  split_measure
+} from "./chunk-YUAIWKOM.js";
+import {
+  git_path_quoting,
+  split_assess
+} from "./chunk-OYGNL5RO.js";
+import {
+  changed_paths
+} from "./chunk-AL2H63BP.js";
+import {
+  change_base
+} from "./chunk-FVPRBMHE.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+import {
+  git_spawn
+} from "./chunk-LZNACCHR.js";
+
+// scripts/review/review-size.ts
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+function tracked_counts(raw) {
+  const rows = raw.split("\n").filter((row) => row !== "");
+  if (rows.some((row) => !/^\d+\t\d+\t.+$/u.test(row))) throw new Error("Unknown diff size");
+  const changes = split_assess.parse_numstat(raw);
+  return new Map(
+    changes.map((change) => [git_path_quoting.unquote(change.path), change.changed_lines])
+  );
+}
+async function tracked_numstat(is_staged) {
+  if (is_staged) {
+    return await git_spawn.read([
+      "-c",
+      "core.quotePath=false",
+      "diff",
+      "--cached",
+      "--numstat",
+      "--no-relative",
+      "--no-renames",
+      "--"
+    ]);
+  }
+  const base = await change_base.resolved_through_merge();
+  if (base === void 0) throw new Error("Unresolved change base");
+  return await git_command.diff_numstat_since(base);
+}
+async function untracked_count(root, file) {
+  const content = await readFile(path.join(root, file));
+  if (content.includes(0)) throw new Error("Binary diff size");
+  return split_measure.line_count(content);
+}
+async function counts_here(is_staged) {
+  const counts = tracked_counts(await tracked_numstat(is_staged));
+  if (is_staged) return counts;
+  const files = changed_paths.to_paths(await git_command.untracked_names());
+  const root = await git_spawn.read(["rev-parse", "--show-toplevel"]);
+  const additions = await Promise.all(
+    files.map(async (file) => {
+      const unquoted = git_path_quoting.unquote(file);
+      return [unquoted, await untracked_count(root, unquoted)];
+    })
+  );
+  return new Map([...counts, ...additions]);
+}
+function total_of(counts) {
+  let total = 0;
+  for (const lines of counts.values()) total += lines;
+  return total;
+}
+async function read(paths, is_staged = false) {
+  try {
+    const counts = await counts_here(is_staged);
+    if (paths.some((file) => !counts.has(git_path_quoting.unquote(file)))) return void 0;
+    return total_of(counts);
+  } catch {
+    return void 0;
+  }
+}
+var review_size = { read };
+
+export {
+  review_size
+};

package/dist/commands/chunk-D6UXGFJ7.js

@@ -0,0 +1,44 @@
+import {
+  acceptance_map
+} from "./chunk-VP3P7FLJ.js";
+import {
+  git_gh_command
+} from "./chunk-VJNE7W7O.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+
+// scripts/review/acceptance-map-check.ts
+var ISSUE_SEPARATOR = "#";
+async function is_found(deferral) {
+  const [repo, number = ""] = deferral.issue.split(ISSUE_SEPARATOR);
+  const read = await git_gh_command.issue_get_body_classified(
+    number,
+    repo === "" ? void 0 : repo
+  );
+  return read.kind === "read";
+}
+async function absent_deferrals(deferrals) {
+  const found = await Promise.all(deferrals.map(async (deferral) => await is_found(deferral)));
+  return deferrals.filter((_deferral, index) => found[index] !== true).map((deferral) => `- \`${deferral.id}\` names ${deferral.issue}`);
+}
+function unreadable_message(issue) {
+  return `Issue ${session_cite.issue(issue)} could not be re-read to check its acceptance criteria, so the merge is refused; re-run once it can be.`;
+}
+async function body_refusal(issue, pr_body) {
+  const issue_read = await git_gh_command.issue_get_body_classified(issue);
+  if (issue_read.kind !== "read") return unreadable_message(issue);
+  const criteria = acceptance_map.criteria_of(issue_read.text);
+  const comparison = acceptance_map.compare(criteria, acceptance_map.rows_of(pr_body));
+  const absent = await absent_deferrals(comparison.deferrals);
+  if (comparison.missing.length === 0 && absent.length === 0) return void 0;
+  return acceptance_map.refusal_message(issue, comparison, absent);
+}
+async function refusal(issue, branch_name) {
+  return await body_refusal(issue, await git_gh_command.pr_get_body(branch_name));
+}
+var acceptance_map_check = { body_refusal, refusal };
+
+export {
+  acceptance_map_check
+};

package/dist/commands/chunk-DIXUXHZ2.js

@@ -0,0 +1,207 @@
+import {
+  backlog_budget
+} from "./chunk-BYSPYVLD.js";
+import {
+  agent_profile_schema
+} from "./chunk-F7B4ESZE.js";
+import {
+  process_owner_schema
+} from "./chunk-HLUS2M3D.js";
+import {
+  durable_state
+} from "./chunk-JSJS3OT7.js";
+import {
+  process_identity
+} from "./chunk-F2RDEF2J.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/run/wake/run-wake.ts
+import { z } from "zod";
+var WAKE_PREFIX = "josh-run-wake-";
+var WAKE_LOG_PREFIX = durable_state.PREFIX.WAKE_LOG;
+var WAKE_LOG_SUFFIX = ".log";
+var WAKE_GRACE_MS = 6e5;
+var MAX_WAKE_ATTEMPTS = 3;
+var IDLE_CEILING_MS = backlog_budget.DEFAULT_IDLE_MS;
+var NO_WAKES = 0;
+var ONE_WAKE = 1;
+var WAKE_DECISION = { kind: "wake" };
+var IDLE_DECISION = { kind: "idle" };
+var WAIT_DECISION = { kind: "wait" };
+var PENDING_DECISION = { kind: "pending" };
+var FAILED_DECISION = { kind: "failed" };
+var STOP_REASONS = {
+  none: "ended",
+  unreadable: "unreadable"
+};
+var run_wake_schema = process_owner_schema.extend({
+  invocation: z.string(),
+  started_at: z.string(),
+  woke: z.number(),
+  woke_at: z.string().optional(),
+  launch_at: z.string().optional(),
+  // Every optional `RunWake` field must be listed: `z.object` strips undeclared ones on the round trip.
+  attempts: z.number().optional(),
+  woke_pid: z.number().optional(),
+  spawned: z.array(z.string()).optional(),
+  idle_since: z.string().optional(),
+  profile: agent_profile_schema.PROFILE_SCHEMA.optional()
+});
+function is_overdue(marked_at, now, limit_ms = WAKE_GRACE_MS) {
+  const marked = Date.parse(marked_at);
+  if (Number.isNaN(marked)) return true;
+  return now.getTime() - marked > limit_ms;
+}
+function launch_or_idle(input) {
+  if (input.has_work !== false) return WAKE_DECISION;
+  if (input.idle_since === void 0) return IDLE_DECISION;
+  return is_overdue(input.idle_since, input.now, IDLE_CEILING_MS) ? WAKE_DECISION : IDLE_DECISION;
+}
+function decide_launch(input) {
+  if (input.woke_at === void 0) return launch_or_idle(input);
+  if (!is_overdue(input.woke_at, input.now)) return PENDING_DECISION;
+  return input.attempts < MAX_WAKE_ATTEMPTS ? launch_or_idle(input) : FAILED_DECISION;
+}
+function decide_not_handed_off(input) {
+  if (input.is_owner_live) return WAIT_DECISION;
+  return decide_launch(input);
+}
+function decide(input) {
+  if (input.read.kind !== "carried") return { kind: "stop", reason: STOP_REASONS[input.read.kind] };
+  if (input.read.carry.is_handed_off !== true) return decide_not_handed_off(input);
+  return decide_launch(input);
+}
+function wake_path(git_directory) {
+  return stamp_file.stamp_path(WAKE_PREFIX, git_directory);
+}
+function wake_log_path(git_directory) {
+  return durable_state.path(WAKE_LOG_PREFIX, git_directory, WAKE_LOG_SUFFIX);
+}
+function parse_wake(raw) {
+  return json_value.parse_with(raw, run_wake_schema);
+}
+function read_wake(target) {
+  const raw = stamp_file.read_stamp_text(target);
+  return raw === void 0 ? void 0 : parse_wake(raw);
+}
+function write_wake(target, wake) {
+  stamp_file.write_stamp(target, wake);
+}
+function remove_wake(target) {
+  stamp_file.remove_stamp(target);
+}
+function fresh_wake(invocation, now, profile) {
+  return {
+    invocation,
+    ...profile && { profile },
+    started_at: now.toISOString(),
+    woke: NO_WAKES,
+    ...process_identity.own_fields()
+  };
+}
+function is_supervisor_live(wake) {
+  return process_identity.is_same_process(wake.pid, wake.process_start) !== false;
+}
+function carried_state(existing, invocation) {
+  if (existing?.invocation !== invocation) return { woke: NO_WAKES };
+  return {
+    woke: existing.woke,
+    woke_at: existing.woke_at,
+    launch_at: existing.launch_at,
+    attempts: existing.attempts,
+    woke_pid: existing.woke_pid,
+    spawned: existing.spawned,
+    idle_since: existing.idle_since,
+    ...existing.profile && { profile: existing.profile }
+  };
+}
+function is_held_by_live_supervisor(existing) {
+  return existing !== void 0 && is_supervisor_live(existing);
+}
+function reclaim(target, wake) {
+  if (is_held_by_live_supervisor(read_wake(target))) return void 0;
+  remove_wake(target);
+  return stamp_file.create_stamp(target, wake) ? wake : void 0;
+}
+function claim(target, invocation, now, profile) {
+  const existing = read_wake(target);
+  if (is_held_by_live_supervisor(existing)) return void 0;
+  const wake = { ...fresh_wake(invocation, now, profile), ...carried_state(existing, invocation) };
+  return stamp_file.create_stamp(target, wake) ? wake : reclaim(target, wake);
+}
+function count_wake(wake, now, pid, session_id) {
+  const attempts = (wake.attempts ?? NO_WAKES) + ONE_WAKE;
+  const spawned = [...wake.spawned ?? [], session_id];
+  const woke_at = now.toISOString();
+  return {
+    ...wake,
+    attempts,
+    spawned,
+    woke_at,
+    woke_pid: pid,
+    idle_since: void 0
+  };
+}
+function mark_idle(wake, now) {
+  return wake.idle_since === void 0 ? { ...wake, idle_since: now.toISOString() } : wake;
+}
+function count_claim(wake) {
+  const woke = wake.woke_at === void 0 ? wake.woke : wake.woke + ONE_WAKE;
+  return {
+    ...wake,
+    woke,
+    launch_at: wake.woke_at ?? wake.launch_at,
+    woke_at: void 0,
+    attempts: void 0,
+    idle_since: void 0
+  };
+}
+function is_own_wake(wake) {
+  return process_identity.is_own_process(wake.pid, wake.process_start);
+}
+function read_own_wake(target) {
+  const wake = read_wake(target);
+  return wake !== void 0 && is_own_wake(wake) ? wake : void 0;
+}
+function tidy_own_wake(target) {
+  const wake = read_wake(target);
+  if (wake === void 0) return "absent";
+  if (!is_own_wake(wake)) return "superseded";
+  remove_wake(target);
+  return "removed";
+}
+function update_wake(target, wake) {
+  if (read_own_wake(target) === void 0) return false;
+  write_wake(target, wake);
+  return true;
+}
+var run_wake = {
+  IDLE_CEILING_MS,
+  MAX_WAKE_ATTEMPTS,
+  WAKE_GRACE_MS,
+  claim,
+  count_claim,
+  count_wake,
+  decide,
+  fresh_wake,
+  is_supervisor_live,
+  mark_idle,
+  parse_wake,
+  read_own_wake,
+  read_wake,
+  remove_wake,
+  tidy_own_wake,
+  update_wake,
+  wake_log_path,
+  wake_path,
+  write_wake
+};
+
+export {
+  run_wake
+};

package/dist/commands/chunk-DM6I4PYD.js

@@ -0,0 +1,110 @@
+import {
+  git_gh_etag_read
+} from "./chunk-V6WWW6HX.js";
+import {
+  shared_cache
+} from "./chunk-RW7OILP7.js";
+import {
+  author_fields_schema
+} from "./chunk-34DND4BA.js";
+import {
+  git_gh_api_path
+} from "./chunk-RDRN56E4.js";
+import {
+  parse_json
+} from "./chunk-NAZ753DE.js";
+
+// scripts/gh/gh-permission-cache.ts
+import { z } from "zod";
+var MS_KEPT = 36e5;
+var WRITERS_CACHE = { prefix: "josh-write-permission-", ttl_ms: MS_KEPT };
+var entries_schema = z.array(z.object({ login: z.string(), read_at: z.number() }));
+function fresh_entries(repo, now_ms) {
+  const entries = shared_cache.read(WRITERS_CACHE, repo, entries_schema, now_ms) ?? [];
+  return entries.filter((entry) => entry.read_at <= now_ms && now_ms - entry.read_at < MS_KEPT);
+}
+function is_writer(repo, login, now_ms = Date.now()) {
+  return fresh_entries(repo, now_ms).some((entry) => entry.login === login);
+}
+function remember_writer(repo, login, now_ms = Date.now()) {
+  const fresh = fresh_entries(repo, now_ms);
+  if (fresh.some((entry) => entry.login === login)) return;
+  shared_cache.write(WRITERS_CACHE, repo, [...fresh, { login, read_at: now_ms }], now_ms);
+}
+var gh_permission_cache = { WRITERS_CACHE, is_writer, remember_writer };
+
+// scripts/gh/gh-author-association.ts
+import { z as z2 } from "zod";
+var OWNER = "OWNER";
+var ASKED_ASSOCIATIONS = /* @__PURE__ */ new Set(["MEMBER", "COLLABORATOR"]);
+var WRITE_ROLES = /* @__PURE__ */ new Set(["admin", "maintain", "write"]);
+var LOGIN_PATTERN = /^[\da-z](?:[\w-]*[\da-z])?$/iu;
+var TRUSTED_LIST = "OWNER, or MEMBER / COLLABORATOR with write access";
+var AUTHOR_FIELDS = "author_association,user";
+var permission_schema = z2.looseObject({
+  permission: z2.string().nullish(),
+  role_name: z2.string().nullish()
+});
+var answers = /* @__PURE__ */ new Map();
+function permission_path(login, repo) {
+  return `${git_gh_api_path.repo_api_path(repo)}/collaborators/${login}/permission`;
+}
+function has_write_role(raw) {
+  const parsed = parse_json.parse_json_object_or_undefined(raw, permission_schema);
+  const roles = [parsed?.role_name, parsed?.permission];
+  return roles.some((role) => typeof role === "string" && WRITE_ROLES.has(role));
+}
+async function read_permission(asked) {
+  try {
+    const path = permission_path(asked.login, asked.repo);
+    const raw = await git_gh_etag_read.read(path, asked.timeout_ms);
+    return has_write_role(raw);
+  } catch {
+    return void 0;
+  }
+}
+async function ask_permission(asked) {
+  if (asked.is_shared !== true) return await read_permission(asked);
+  const repo = asked.repo ?? "";
+  if (gh_permission_cache.is_writer(repo, asked.login)) return true;
+  const has_write = await read_permission(asked);
+  if (has_write === true) gh_permission_cache.remember_writer(repo, asked.login);
+  return has_write;
+}
+async function can_write(author) {
+  const key = `${author.repo ?? ""} ${author.login}`;
+  const asked = answers.get(key) ?? ask_permission(author);
+  answers.set(key, asked);
+  const has_write = await asked;
+  if (has_write === void 0 && answers.get(key) === asked) answers.delete(key);
+  return has_write;
+}
+function is_user_login(login) {
+  return login !== void 0 && LOGIN_PATTERN.test(login);
+}
+function is_asked(author) {
+  return ASKED_ASSOCIATIONS.has(author.association ?? "") && is_user_login(author.login);
+}
+async function trust_of(author) {
+  if (author.association === OWNER) return true;
+  if (author.login === void 0 || !is_asked(author)) return false;
+  return await can_write({ ...author, login: author.login });
+}
+async function is_trusted(author) {
+  return await trust_of(author) === true;
+}
+function author_of(row, timeout_ms) {
+  return { login: row.user?.login, association: row.author_association, timeout_ms };
+}
+var gh_author_association = {
+  AUTHOR_FIELDS,
+  TRUSTED_LIST,
+  author_fields_schema,
+  author_of,
+  is_trusted,
+  trust_of
+};
+
+export {
+  gh_author_association
+};