@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-J6WKZRV2.js

@@ -1,391 +0,0 @@
-import {
-  vitest_failure_summary
-} from "./chunk-KB3OQWDT.js";
-import {
-  test_read_map,
-  test_read_trace
-} from "./chunk-OZZWRJQI.js";
-import {
-  changed_file_scope
-} from "./chunk-7LJQMM2K.js";
-import {
-  input_fingerprint
-} from "./chunk-MGF64OHV.js";
-import {
-  project_checks
-} from "./chunk-JM6EVOFN.js";
-import {
-  SKIP_MARKER
-} from "./chunk-IW6NWCSN.js";
-import {
-  core_admission,
-  core_budget,
-  held_mark
-} from "./chunk-TCBUX52E.js";
-import {
-  machine_capacity
-} from "./chunk-KXHXMERX.js";
-import {
-  unit_worker_share
-} from "./chunk-MDLOETXL.js";
-import {
-  PROJECT_ENVIRONMENT_KEYS
-} from "./chunk-IGD6QJPH.js";
-import {
-  changed_paths
-} from "./chunk-V5FD7DVV.js";
-import {
-  core_weights
-} from "./chunk-ENFPR7J2.js";
-import {
-  direct_launch
-} from "./chunk-SVV4U5AR.js";
-import {
-  git_command
-} from "./chunk-AKQYYHP2.js";
-import {
-  git_spawn
-} from "./chunk-CJKPF5DJ.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/test/test-unit-guard.ts
-import { existsSync, globSync } from "node:fs";
-import { availableParallelism as availableParallelism2 } from "node:os";
-import path2 from "node:path";
-
-// scripts/gate/free-cores.ts
-import { availableParallelism } from "node:os";
-function running_claims(directory) {
-  const own = held_mark.held_reservation();
-  return core_budget.live_reservations(directory).filter((entry) => entry.key !== own);
-}
-function free_of(reading, options) {
-  if (reading.busy_cores === void 0) return void 0;
-  const ledger = core_admission.ledger_load(running_claims(options.directory), Date.now());
-  return machine_capacity.machine_budget(
-    options.available_cores ?? availableParallelism(),
-    reading,
-    ledger
-  ).cores;
-}
-function workers_in_memory(available_mb) {
-  if (available_mb === void 0) return void 0;
-  return available_mb / core_weights.MEMORY_MB.unit_worker;
-}
-async function read(options = {}) {
-  const reading = await (options.read_machine ?? machine_capacity.read_machine)();
-  return {
-    cores: free_of(reading, options),
-    memory_workers: workers_in_memory(reading.available_mb)
-  };
-}
-var free_cores = { read };
-
-// scripts/test/test-unit-guard.ts
-import { execa as execa2 } from "execa";
-
-// scripts/test/project-test-script.ts
-import { execa } from "execa";
-var PNPM = "pnpm";
-var SCRIPT_NAME = "test";
-var FAIL_EXIT_CODE = 1;
-var INIT_PLACEHOLDER = 'echo "Error: no test specified" && exit 1';
-var REENTRY_KEY = "JOSH_PROJECT_TEST_SCRIPT";
-var REENTRY_VALUE = "1";
-var EMPTY_COMMANDS = /* @__PURE__ */ new Set(["", INIT_PLACEHOLDER]);
-function field_of(value, key) {
-  return json_value.is_record(value) ? value[key] : void 0;
-}
-function declared_script(project_directory) {
-  const manifest = project_checks.read_manifest(project_directory);
-  const script = field_of(field_of(manifest, "scripts"), SCRIPT_NAME);
-  if (typeof script !== "string") return void 0;
-  const command = script.trim();
-  return EMPTY_COMMANDS.has(command) ? void 0 : command;
-}
-function state(project_directory, environment = process.env) {
-  if (declared_script(project_directory) === void 0) return "absent";
-  return environment[REENTRY_KEY] === REENTRY_VALUE ? "reentrant" : "declared";
-}
-async function run(project_directory, command_label) {
-  console.info(
-    `josh ${command_label}: vitest is not installed \u2014 running the project's own test script (${PNPM} run ${SCRIPT_NAME}).`
-  );
-  const result = await execa(PNPM, ["run", SCRIPT_NAME], {
-    cwd: project_checks.project_root(project_directory),
-    env: { [REENTRY_KEY]: REENTRY_VALUE },
-    stdio: "inherit",
-    reject: false
-  });
-  return result.exitCode ?? FAIL_EXIT_CODE;
-}
-var project_test_script = { INIT_PLACEHOLDER, REENTRY_KEY, declared_script, state, run };
-
-// scripts/test/test-read-recording.ts
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import path from "node:path";
-var RUN_SUBCOMMAND = "run";
-var WORKER_FLAG_PREFIX = "--maxWorkers";
-var RECORD_DIRECTORY_PREFIX = "josh-test-reads-";
-function is_recordable(vitest_arguments) {
-  const [subcommand, ...flags] = vitest_arguments;
-  return subcommand === RUN_SUBCOMMAND && flags.every((flag) => flag.startsWith(WORKER_FLAG_PREFIX));
-}
-async function commit_directories(commit) {
-  const output = await git_spawn.read(["ls-tree", "-r", "-d", "--name-only", "-z", commit]);
-  return output.split("\0").filter((listed) => listed.length > 0);
-}
-async function own_change() {
-  try {
-    return await changed_paths.read_changed_paths(false);
-  } catch {
-    return [];
-  }
-}
-async function tree_snapshot(root) {
-  const commit = await git_command.head_commit();
-  const dirty = input_fingerprint.of_files(root, await changed_paths.read_changed_since(commit));
-  const change = await own_change();
-  return { commit, dirty, change, directories: await commit_directories(commit) };
-}
-function save_map(root, directory, snapshot) {
-  try {
-    const readers = test_read_map.merge_records(test_read_map.collect_records(directory));
-    test_read_map.write_map(root, { version: test_read_map.MAP_VERSION, ...snapshot, readers });
-  } catch {
-  }
-}
-async function with_read_recording(root, vitest_arguments, run2) {
-  if (!is_recordable(vitest_arguments)) return await run2({});
-  const directory = mkdtempSync(path.join(tmpdir(), RECORD_DIRECTORY_PREFIX));
-  try {
-    const [tree] = await Promise.allSettled([tree_snapshot(root)]);
-    const exit_code = await run2({
-      [test_read_trace.RECORD_DIRECTORY_KEY]: directory,
-      [test_read_trace.ROOT_KEY]: root
-    });
-    if (exit_code === 0 && tree.status === "fulfilled") save_map(root, directory, tree.value);
-    return exit_code;
-  } finally {
-    rmSync(directory, { recursive: true, force: true });
-  }
-}
-var test_read_recording = { is_recordable, with_read_recording };
-
-// scripts/test/unit-update-arguments.ts
-var UPDATE_VALUES = {
-  all: true,
-  new: true,
-  none: true,
-  true: true,
-  false: true
-};
-var UPDATE_FLAGS = /* @__PURE__ */ new Set(["-u", "--update"]);
-var OPTION_PREFIX = "-";
-var NOT_FOUND = -1;
-function is_filter_word(value) {
-  if (value === void 0 || value.startsWith(OPTION_PREFIX)) return false;
-  return !Object.hasOwn(UPDATE_VALUES, value);
-}
-function filter_words(vitest_arguments) {
-  const next_option = vitest_arguments.findIndex((argument) => argument.startsWith(OPTION_PREFIX));
-  return next_option === NOT_FOUND ? vitest_arguments : vitest_arguments.slice(0, next_option);
-}
-function filter_flag(vitest_arguments) {
-  const delimiter = vitest_arguments.indexOf("--");
-  const options = delimiter === NOT_FOUND ? vitest_arguments : vitest_arguments.slice(0, delimiter);
-  return options.findIndex(
-    (argument, index) => UPDATE_FLAGS.has(argument) && is_filter_word(options[index + 1])
-  );
-}
-function reorder(vitest_arguments) {
-  const flag_index = filter_flag(vitest_arguments);
-  const value = flag_index === NOT_FOUND ? void 0 : vitest_arguments[flag_index + 1];
-  if (!is_filter_word(value)) return { arguments: vitest_arguments };
-  const filters = filter_words(vitest_arguments.slice(flag_index + 1));
-  const ordered = vitest_arguments.toSpliced(flag_index + 1, filters.length);
-  return {
-    arguments: reorder(ordered.toSpliced(flag_index, 0, ...filters)).arguments,
-    filter: value
-  };
-}
-function notice(filter) {
-  return `moved "${filter}" in front of the update flag \u2014 vitest reads the word after it as the update type, not a file filter.`;
-}
-var unit_update_arguments = {
-  notice,
-  reorder
-};
-
-// scripts/test/test-unit-guard.ts
-var FAIL_EXIT_CODE2 = 1;
-var VITEST_PACKAGE = path2.join("node_modules", "vitest");
-var UNIT_GLOB = "**/*.{test,spec}.{ts,js}";
-var NODE_MODULES = "node_modules";
-var SKIP_ACTION = "skip-missing-package";
-var SKIP_NO_TESTS_ACTION = "skip-no-tests";
-var SKIP_NO_SCRIPT_ACTION = "skip-no-test-script";
-var SKIP_REENTRANT_ACTION = "skip-reentrant";
-var RUN_SCRIPT_ACTION = "run-project-script";
-var FAIL_ACTION = "fail-no-tests";
-var VITEST_SUBJECT = "vitest unit tests";
-var UNIT_SUBJECT = "unit tests";
-var SKIP_NOTICES = {
-  [SKIP_ACTION]: { reason: "vitest is not installed", subject: VITEST_SUBJECT },
-  [SKIP_NO_TESTS_ACTION]: {
-    reason: "no unit test files were found in this basic project",
-    subject: VITEST_SUBJECT
-  },
-  [SKIP_NO_SCRIPT_ACTION]: {
-    reason: "vitest is not installed and package.json declares no test script",
-    subject: UNIT_SUBJECT
-  },
-  [SKIP_REENTRANT_ACTION]: {
-    reason: "the project's test script called back into this check",
-    subject: UNIT_SUBJECT
-  }
-};
-var FAIL_REASON = "vitest is installed but no *.{test,spec}.{ts,js} test file was found \u2014 refusing to report a unit check that ran nothing";
-var BASIC_MISSING_PACKAGE_ACTIONS = {
-  declared: RUN_SCRIPT_ACTION,
-  absent: SKIP_NO_SCRIPT_ACTION,
-  reentrant: SKIP_REENTRANT_ACTION
-};
-function resolve_installed_action(has_tests, is_basic) {
-  if (has_tests) return "run";
-  return is_basic ? SKIP_NO_TESTS_ACTION : FAIL_ACTION;
-}
-function resolve_guard_action(is_installed, has_tests, is_basic = false, script_state = "absent") {
-  if (is_installed) return resolve_installed_action(has_tests, is_basic);
-  return is_basic ? BASIC_MISSING_PACKAGE_ACTIONS[script_state] : SKIP_ACTION;
-}
-function is_vitest_installed(project_directory) {
-  return existsSync(path2.join(project_directory, VITEST_PACKAGE));
-}
-function is_in_node_modules(entry) {
-  return entry.split(/[/\\]/u).includes(NODE_MODULES);
-}
-function has_unit_tests(project_directory) {
-  const matches = globSync(UNIT_GLOB, {
-    cwd: project_directory,
-    exclude: is_in_node_modules
-  });
-  return matches.length > 0;
-}
-function guard_action(project_directory) {
-  return resolve_guard_action(
-    is_vitest_installed(project_directory),
-    has_unit_tests(project_directory),
-    project_checks.is_basic(project_directory),
-    project_test_script.state(project_directory)
-  );
-}
-function is_skip_action(action) {
-  return Object.hasOwn(SKIP_NOTICES, action);
-}
-function is_skipping(project_directory) {
-  return is_skip_action(guard_action(project_directory));
-}
-function is_running(project_directory) {
-  const action = guard_action(project_directory);
-  return action === "run" || action === RUN_SCRIPT_ACTION;
-}
-function isolated_unit_environment(environment = process.env) {
-  const isolated = { ...environment };
-  for (const key of PROJECT_ENVIRONMENT_KEYS) Reflect.deleteProperty(isolated, key);
-  return isolated;
-}
-async function vitest_share(vitest_arguments) {
-  if (unit_worker_share.has_worker_flag(vitest_arguments)) return void 0;
-  const available_cores = availableParallelism2();
-  const free = await free_cores.read({ available_cores });
-  const share = unit_worker_share.current_share(
-    available_cores,
-    unit_worker_share.live_run_count(),
-    free,
-    unit_worker_share.live_lane_count()
-  );
-  return unit_worker_share.cap_to_claim(share, core_budget.held_unit_claim());
-}
-async function execute_vitest(vitest_arguments, recording, directory) {
-  const launch = direct_launch(directory, ["exec", "vitest", ...vitest_arguments]);
-  const result = await execa2(launch.file, [...launch.args], {
-    cwd: directory,
-    env: { ...isolated_unit_environment(), ...recording },
-    extendEnv: false,
-    stdin: "inherit",
-    stdout: ["inherit", "pipe"],
-    stderr: ["inherit", "pipe"],
-    all: true,
-    reject: false
-  });
-  const exit_code = result.exitCode ?? FAIL_EXIT_CODE2;
-  vitest_failure_summary.report(vitest_arguments, result.all, exit_code);
-  return exit_code;
-}
-async function run_vitest(vitest_arguments, directory = process.cwd()) {
-  return await unit_worker_share.with_run_marker(async () => {
-    const sized = [
-      ...vitest_arguments,
-      ...unit_worker_share.worker_arguments(vitest_arguments, await vitest_share(vitest_arguments))
-    ];
-    const root = await changed_file_scope.repository_root_or_cwd();
-    return await test_read_recording.with_read_recording(
-      root,
-      sized,
-      async (recording) => await execute_vitest(sized, recording, directory)
-    );
-  });
-}
-async function run_vitest_in(directory, vitest_arguments) {
-  return await run_vitest(vitest_arguments, directory);
-}
-var UNIT_COMMAND_LABEL = "test:unit";
-function report_no_run(action, command_label) {
-  if (action === FAIL_ACTION) {
-    console.error(`josh ${command_label}: ${FAIL_REASON}.`);
-    return FAIL_EXIT_CODE2;
-  }
-  const { reason, subject } = SKIP_NOTICES[action];
-  console.info(`josh ${command_label}: ${reason} ${SKIP_MARKER} ${subject}.`);
-  return 0;
-}
-async function run_guarded_vitest(project_directory, vitest_arguments, command_label = UNIT_COMMAND_LABEL, announcement) {
-  const action = guard_action(project_directory);
-  if (action === RUN_SCRIPT_ACTION) {
-    return await project_test_script.run(project_directory, command_label);
-  }
-  if (action !== "run") return report_no_run(action, command_label);
-  if (announcement !== void 0) process.stdout.write(`${announcement}
-`);
-  return await run_vitest(vitest_arguments);
-}
-async function run_guarded_unit(project_directory, extra_arguments) {
-  const { arguments: ordered, filter } = unit_update_arguments.reorder(extra_arguments);
-  if (filter !== void 0) {
-    console.info(`josh ${UNIT_COMMAND_LABEL}: ${unit_update_arguments.notice(filter)}`);
-  }
-  return await run_guarded_vitest(project_directory, ["run", ...ordered]);
-}
-var test_unit_guard = {
-  SKIP_MARKER,
-  guard_action,
-  is_skipping,
-  is_running,
-  resolve_guard_action,
-  is_vitest_installed,
-  has_unit_tests,
-  isolated_unit_environment,
-  run_guarded_unit,
-  run_guarded_vitest,
-  run_vitest_in,
-  vitest_share
-};
-
-export {
-  free_cores,
-  test_unit_guard
-};

package/dist/commands/chunk-J7IO3AYH.js

@@ -1,179 +0,0 @@
-import {
-  issue_watch_diff
-} from "./chunk-RW64VHEB.js";
-import {
-  git_gh_issue_read
-} from "./chunk-ENKFCOVY.js";
-import {
-  gh_author_association
-} from "./chunk-XXNEY4B3.js";
-import {
-  git_gh_conditional
-} from "./chunk-EWVR5AEX.js";
-import {
-  git_gh_api_path
-} from "./chunk-RDRN56E4.js";
-import {
-  stamp_file
-} from "./chunk-QWWTC3XR.js";
-import {
-  PROJECT_ROOT
-} from "./chunk-3CCGKX7Y.js";
-import {
-  git_command
-} from "./chunk-AKQYYHP2.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/issue/issue-watch.ts
-import { z } from "zod";
-var RECORD_PREFIX = "josh-issue-watch-";
-var CLOSED_STATE = "closed";
-var record_schema = z.object({
-  issue: z.string(),
-  body: z.string(),
-  last_comment_id: z.number(),
-  acknowledged_at: z.string(),
-  checked_at: z.string(),
-  etag: z.string().optional(),
-  pending: z.string().optional(),
-  // A body edit withheld from the run (`issue_watch_diff.withheld_notice`) — shown, never a hold.
-  notice: z.string().optional(),
-  shown: z.string().optional()
-});
-var issue_schema = z.looseObject({
-  body: z.string().nullish(),
-  state: z.string(),
-  updated_at: z.string().optional(),
-  ...gh_author_association.author_fields_schema
-});
-var UNREADABLE = { kind: "unreadable" };
-function record_path(root = PROJECT_ROOT) {
-  return stamp_file.stamp_path(RECORD_PREFIX, root);
-}
-function read_record(root) {
-  const raw = stamp_file.read_stamp_text(record_path(root));
-  return raw === void 0 ? void 0 : json_value.parse_with(raw, record_schema);
-}
-function write_record(record, root) {
-  stamp_file.replace_stamp(record_path(root), record);
-  return record;
-}
-function clear(root) {
-  stamp_file.remove_stamp(record_path(root));
-}
-async function read_comments(request) {
-  return await issue_watch_diff.parse_comments(
-    await git_gh_issue_read.issue_list_comments(request.issue, request.timeout_ms),
-    request.timeout_ms
-  );
-}
-async function read_snapshot(request, issue, etag) {
-  const [comments, is_body_trusted] = await Promise.all([
-    read_comments(request),
-    gh_author_association.trust_of(gh_author_association.author_of(issue, request.timeout_ms))
-  ]);
-  if (comments === void 0) return UNREADABLE;
-  const snapshot = { body: issue.body ?? "", is_body_trusted, comments };
-  return { kind: "read", snapshot, etag, ...issue.updated_at && { updated_at: issue.updated_at } };
-}
-async function fetch_issue(request) {
-  const read = await git_gh_conditional.read_conditional(
-    git_gh_api_path.issue_api_path(request.issue),
-    request.etag,
-    request.timeout_ms
-  );
-  if (read.kind !== "changed") return read;
-  const fields = json_value.parse_with(read.body, issue_schema);
-  if (fields === void 0) return UNREADABLE;
-  if (fields.state === CLOSED_STATE) return { kind: "closed" };
-  return await read_snapshot(request, fields, read.etag);
-}
-function fresh_record(issue, fetched, now, acknowledged_at = now.toISOString()) {
-  const baseline = issue_watch_diff.baseline_of(fetched.snapshot);
-  const checked_at = now.toISOString();
-  return { issue, ...baseline, acknowledged_at, checked_at, etag: fetched.etag };
-}
-function kept_acknowledgement(previous, issue, fetched) {
-  if (previous?.issue !== issue) return void 0;
-  const diff = issue_watch_diff.unread_diff(previous, fetched.snapshot);
-  return diff === void 0 ? previous.acknowledged_at : void 0;
-}
-async function record_baseline(issue, root, now = /* @__PURE__ */ new Date()) {
-  const fetched = await fetch_issue({ issue });
-  if (fetched.kind !== "read") return false;
-  const acknowledged_at = kept_acknowledgement(read_record(root), issue, fetched);
-  write_record(fresh_record(issue, fetched, now, acknowledged_at), root);
-  return true;
-}
-async function record_baseline_here(issue) {
-  return await record_baseline(issue, await git_command.repository_root());
-}
-async function clear_here() {
-  clear(await git_command.repository_root());
-}
-function with_fetched(record, fetched, checked_at) {
-  if (fetched.kind !== "read") return { ...record, checked_at };
-  const pending = issue_watch_diff.unread_diff(record, fetched.snapshot);
-  const notice = issue_watch_diff.withheld_notice(record, fetched.snapshot);
-  return { ...record, checked_at, etag: fetched.etag, pending, notice };
-}
-function is_due(record, options, now) {
-  return now.getTime() - Date.parse(record.checked_at) >= options.interval_ms;
-}
-async function refresh(record, options, now, root) {
-  const fetched = await fetch_issue({
-    issue: record.issue,
-    etag: record.etag,
-    timeout_ms: options.timeout_ms
-  });
-  if (fetched.kind === "closed") {
-    clear(root);
-    return void 0;
-  }
-  return write_record(with_fetched(record, fetched, now.toISOString()), root);
-}
-async function poll(options, root) {
-  const record = read_record(root);
-  const now = options.now ?? /* @__PURE__ */ new Date();
-  if (record === void 0 || !is_due(record, options, now)) return record;
-  return await refresh(record, options, now, root);
-}
-function news_of(record) {
-  return record.pending ?? record.notice;
-}
-function mark_shown(record, root) {
-  return write_record({ ...record, shown: news_of(record) }, root);
-}
-function landed_at(record, fetched, now) {
-  const times = issue_watch_diff.landed_times(record, fetched.snapshot, fetched.updated_at ?? "");
-  const landed = times.map((time) => Math.min(Date.parse(time) || now.getTime(), now.getTime()));
-  return new Date(Math.max(...landed, Date.parse(record.acknowledged_at) || 0)).toISOString();
-}
-async function acknowledge(root, now = /* @__PURE__ */ new Date()) {
-  const record = read_record(root);
-  if (record === void 0) return void 0;
-  const fetched = await fetch_issue({ issue: record.issue });
-  if (fetched.kind !== "read") return void 0;
-  const diff = issue_watch_diff.unread_diff(record, fetched.snapshot);
-  const acknowledged_at = diff === void 0 ? record.acknowledged_at : landed_at(record, fetched, now);
-  write_record(fresh_record(record.issue, fetched, now, acknowledged_at), root);
-  return { issue: record.issue, diff };
-}
-var issue_watch = {
-  acknowledge,
-  clear,
-  clear_here,
-  mark_shown,
-  news_of,
-  poll,
-  read_record,
-  record_baseline,
-  record_baseline_here,
-  record_path
-};
-
-export {
-  issue_watch
-};

package/dist/commands/chunk-JAKC2BHX.js

@@ -1,88 +0,0 @@
-import {
-  with_page_size
-} from "./chunk-B3M5WSGN.js";
-import {
-  poll
-} from "./chunk-SBGTCT2C.js";
-import {
-  git_gh_exec
-} from "./chunk-XDF25GSU.js";
-import {
-  GH_API_TIMEOUT_MS
-} from "./chunk-WPAQUMHC.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/propagate/propagate-publish.ts
-var VERSIONS_PAGE_SIZE = 100;
-var NAMES_JQ = "[.[] | .name]";
-var DEFAULT_TIMEOUT_MS = 6e5;
-var DEFAULT_INTERVAL_MS = 15e3;
-var UNREADABLE_THRESHOLD = 3;
-function is_version_published(published_versions, target_version) {
-  return published_versions.includes(target_version);
-}
-function should_keep_waiting(now_ms, deadline_ms) {
-  return now_ms < deadline_ms;
-}
-function finish(state, version, attempts) {
-  return { state, version, attempts };
-}
-function fetch_published_versions(versions_endpoint) {
-  const endpoint = with_page_size(versions_endpoint, VERSIONS_PAGE_SIZE);
-  const stdout = git_gh_exec.read_gh_api_sync({
-    path: endpoint,
-    jq_filter: NAMES_JQ,
-    timeout_ms: GH_API_TIMEOUT_MS
-  });
-  if (stdout === void 0) return void 0;
-  return json_value.parse_array(stdout)?.filter((name) => typeof name === "string");
-}
-var WAIT_DEFAULTS = {
-  timeout_ms: DEFAULT_TIMEOUT_MS,
-  interval_ms: DEFAULT_INTERVAL_MS,
-  fetch_versions: fetch_published_versions,
-  sleep: poll.sleep,
-  now: Date.now
-};
-function resolve_wait_options(options) {
-  return { ...WAIT_DEFAULTS, ...options };
-}
-function probe_state(versions, target_version, consecutive_failures) {
-  if (versions === void 0) {
-    return consecutive_failures >= UNREADABLE_THRESHOLD ? "unreadable" : void 0;
-  }
-  return is_version_published(versions, target_version) ? "published" : void 0;
-}
-function probe_once(resolved, versions_endpoint, target_version, progress) {
-  progress.attempts += 1;
-  const versions = resolved.fetch_versions(versions_endpoint);
-  progress.failures = versions === void 0 ? progress.failures + 1 : 0;
-  const state = probe_state(versions, target_version, progress.failures);
-  return state === void 0 ? {} : { state };
-}
-async function wait_for_publish(versions_endpoint, target_version, options = {}) {
-  const resolved = resolve_wait_options(options);
-  const deadline = resolved.now() + resolved.timeout_ms;
-  const progress = { attempts: 0, failures: 0 };
-  const state = await poll.wait_for(
-    () => {
-      if (!should_keep_waiting(resolved.now(), deadline)) return "timed_out";
-      return probe_once(resolved, versions_endpoint, target_version, progress).state;
-    },
-    { interval_ms: resolved.interval_ms, sleeper: resolved.sleep }
-  );
-  return finish(state, target_version, progress.attempts);
-}
-var propagate_publish = {
-  UNREADABLE_THRESHOLD,
-  is_version_published,
-  should_keep_waiting,
-  fetch_published_versions,
-  wait_for_publish
-};
-
-export {
-  propagate_publish
-};