saturndocs 0.1.0

package/dist/index.js

@@ -0,0 +1,191 @@
+import {
+  createBundleArchive,
+  deployBundle
+} from "./chunk-I6U4V7B4.js";
+import {
+  scanBrokenLinks
+} from "./chunk-OEAEX5YW.js";
+import {
+  renderTable
+} from "./chunk-J6P3VGGE.js";
+import {
+  PAGES_METADATA,
+  pagesLimitations,
+  registerPages
+} from "./chunk-XO4CUC7V.js";
+import {
+  STATUS_METADATA,
+  registerStatus,
+  statusText
+} from "./chunk-3V753MRI.js";
+import {
+  BrandFetcher,
+  DEFAULT_PRIMARY_COLOR,
+  buildDocsConfig,
+  colorToHex,
+  deriveDocsJson,
+  extensionForContentType,
+  extractBrandFromUrl,
+  extractBrandText,
+  extractCssColorCandidates,
+  extractManifestUrl,
+  extractStylesheetUrls,
+  extractThemeColorMetas,
+  fetchBrandAsset,
+  normalizeHexColor,
+  normalizeHttpUrl,
+  parseCssColor,
+  pickPrimaryColor,
+  scaffoldDocsProject,
+  scoreColorCandidates,
+  selectLogoAssets
+} from "./chunk-SABK3R2P.js";
+import {
+  collectPageEntries,
+  pageUrl,
+  resolvePageFile,
+  validateDocs
+} from "./chunk-OZWTXMO3.js";
+import "./chunk-S45UWCML.js";
+import "./chunk-R3X2DPFF.js";
+import {
+  findWebDir,
+  findWorkspaceRoot
+} from "./chunk-VXEUNRVA.js";
+import "./chunk-VNYDYHXM.js";
+import {
+  MANAGE_METADATA
+} from "./chunk-STCCGFKC.js";
+import {
+  REQUESTS_CREATE_METADATA,
+  REQUESTS_METADATA,
+  registerRequests,
+  registerRequestsCreate
+} from "./chunk-U7PKMSB3.js";
+import {
+  STDIN_BYTE_CEILING,
+  readTextInput
+} from "./chunk-N7QPZMLP.js";
+import {
+  SCHEMA_METADATA,
+  registerSchema,
+  schemaDocument
+} from "./chunk-5KX4ZK5E.js";
+import {
+  COMMAND_GROUPS,
+  COMMAND_GROUP_NAMES,
+  findCommandGroup,
+  selectCommandGroup
+} from "./chunk-QLFODLVN.js";
+import {
+  AUTH_METADATA,
+  authStatusOf,
+  registerAuth
+} from "./chunk-3P2OFTXR.js";
+import {
+  SITES_METADATA,
+  registerSites,
+  requestedSite
+} from "./chunk-CMNX5DLQ.js";
+import {
+  TOKEN_VARIABLE,
+  asCliError,
+  clientFor
+} from "./chunk-TKISMN3P.js";
+import {
+  installInterrupt,
+  interruptSignal
+} from "./chunk-KGJESHJC.js";
+import {
+  applyCommandHelp,
+  helpBody
+} from "./chunk-M2BZEDAS.js";
+import {
+  CliError,
+  applyGlobalFlags,
+  applyGlobalFlagsDeep,
+  clientError,
+  createResultWriter,
+  failureResult,
+  interrupted,
+  invalidInput,
+  resolveGlobalOptions,
+  successResult,
+  wantsJson
+} from "./chunk-GYRVGWDM.js";
+export {
+  AUTH_METADATA,
+  BrandFetcher,
+  COMMAND_GROUPS,
+  COMMAND_GROUP_NAMES,
+  CliError,
+  DEFAULT_PRIMARY_COLOR,
+  MANAGE_METADATA,
+  PAGES_METADATA,
+  REQUESTS_CREATE_METADATA,
+  REQUESTS_METADATA,
+  SCHEMA_METADATA,
+  SITES_METADATA,
+  STATUS_METADATA,
+  STDIN_BYTE_CEILING,
+  TOKEN_VARIABLE,
+  applyCommandHelp,
+  applyGlobalFlags,
+  applyGlobalFlagsDeep,
+  asCliError,
+  authStatusOf,
+  buildDocsConfig,
+  clientError,
+  clientFor,
+  collectPageEntries,
+  colorToHex,
+  createBundleArchive,
+  createResultWriter,
+  deployBundle,
+  deriveDocsJson,
+  extensionForContentType,
+  extractBrandFromUrl,
+  extractBrandText,
+  extractCssColorCandidates,
+  extractManifestUrl,
+  extractStylesheetUrls,
+  extractThemeColorMetas,
+  failureResult,
+  fetchBrandAsset,
+  findCommandGroup,
+  findWebDir,
+  findWorkspaceRoot,
+  helpBody,
+  installInterrupt,
+  interruptSignal,
+  interrupted,
+  invalidInput,
+  normalizeHexColor,
+  normalizeHttpUrl,
+  pageUrl,
+  pagesLimitations,
+  parseCssColor,
+  pickPrimaryColor,
+  readTextInput,
+  registerAuth,
+  registerPages,
+  registerRequests,
+  registerRequestsCreate,
+  registerSchema,
+  registerSites,
+  registerStatus,
+  renderTable,
+  requestedSite,
+  resolveGlobalOptions,
+  resolvePageFile,
+  scaffoldDocsProject,
+  scanBrokenLinks,
+  schemaDocument,
+  scoreColorCandidates,
+  selectCommandGroup,
+  selectLogoAssets,
+  statusText,
+  successResult,
+  validateDocs,
+  wantsJson
+};

package/dist/init-7T5TEPBH.js

@@ -0,0 +1,14 @@
+import {
+  buildDocsConfig,
+  printExtractionReport,
+  registerInit,
+  scaffoldDocsProject
+} from "./chunk-SABK3R2P.js";
+import "./chunk-R3X2DPFF.js";
+import "./chunk-VNYDYHXM.js";
+export {
+  buildDocsConfig,
+  printExtractionReport,
+  registerInit,
+  scaffoldDocsProject
+};

package/dist/manage-MKH27U3B.js

@@ -0,0 +1,12 @@
+import {
+  MANAGE_METADATA,
+  callManagement,
+  registerManage
+} from "./chunk-STCCGFKC.js";
+import "./chunk-M2BZEDAS.js";
+import "./chunk-GYRVGWDM.js";
+export {
+  MANAGE_METADATA,
+  callManagement,
+  registerManage
+};

package/dist/openapiCheck-KGBQJTIQ.js

@@ -0,0 +1,66 @@
+import {
+  renderTable
+} from "./chunk-J6P3VGGE.js";
+import {
+  parseOpenApiFile
+} from "./chunk-S45UWCML.js";
+import {
+  loadDocsConfig,
+  navigationGroups
+} from "./chunk-R3X2DPFF.js";
+import {
+  messageOf,
+  resolveDocsDir
+} from "./chunk-VNYDYHXM.js";
+
+// src/commands/openapiCheck.ts
+import { existsSync } from "fs";
+import { join } from "path";
+import pc from "picocolors";
+function registerOpenapiCheck(program) {
+  program.command("openapi-check").description("Parse OpenAPI specs and print an operation table").argument("[dir]", "docs directory (contains docs.json)").action(async (dir) => {
+    const docsDir = resolveDocsDir(dir);
+    const config = await loadDocsConfig(join(docsDir, "docs.json"));
+    const specs = navigationGroups(config).filter((group) => group.openapi);
+    if (specs.length === 0) {
+      console.log(pc.dim("No navigation groups declare an openapi file."));
+      return;
+    }
+    let hadError = false;
+    for (const group of specs) {
+      const openapiRel = group.openapi;
+      const openapiPath = join(docsDir, openapiRel);
+      console.log(pc.bold(`
+${group.group} \u2014 ${openapiRel}`));
+      if (!existsSync(openapiPath)) {
+        console.error(pc.red(`  error: file not found: ${openapiRel}`));
+        hadError = true;
+        continue;
+      }
+      try {
+        const spec = await parseOpenApiFile(openapiPath);
+        console.log(pc.dim(`  ${spec.title} v${spec.version}`));
+        const rows = spec.operations.map((op) => [
+          op.method.toUpperCase(),
+          op.path,
+          op.slug,
+          op.summary ?? ""
+        ]);
+        const table = renderTable(
+          ["METHOD", "PATH", "SLUG", "SUMMARY"],
+          rows
+        );
+        console.log(
+          table.split("\n").map((line) => `  ${line}`).join("\n")
+        );
+      } catch (error) {
+        console.error(pc.red(`  error: ${messageOf(error)}`));
+        hadError = true;
+      }
+    }
+    if (hadError) process.exit(1);
+  });
+}
+export {
+  registerOpenapiCheck
+};

package/dist/pages-HIPXRLSY.js

@@ -0,0 +1,15 @@
+import {
+  PAGES_METADATA,
+  pagesLimitations,
+  registerPages
+} from "./chunk-XO4CUC7V.js";
+import "./chunk-CMNX5DLQ.js";
+import "./chunk-TKISMN3P.js";
+import "./chunk-KGJESHJC.js";
+import "./chunk-M2BZEDAS.js";
+import "./chunk-GYRVGWDM.js";
+export {
+  PAGES_METADATA,
+  pagesLimitations,
+  registerPages
+};

package/dist/read-DMSJUEDA.js

@@ -0,0 +1,160 @@
+import {
+  requestedSite
+} from "./chunk-CMNX5DLQ.js";
+import {
+  asCliError,
+  clientFor
+} from "./chunk-TKISMN3P.js";
+import "./chunk-KGJESHJC.js";
+import {
+  applyCommandHelp
+} from "./chunk-M2BZEDAS.js";
+import {
+  ACTIVITY_LIMIT_CEILING,
+  ACTIVITY_OUTCOMES,
+  CliError,
+  activityJobFound,
+  commandMetadata,
+  createResultWriter,
+  failureResult,
+  listActivity,
+  readActivityJob,
+  resolveGlobalOptions,
+  resolveTarget,
+  successResult
+} from "./chunk-GYRVGWDM.js";
+
+// src/commands/activity/read.ts
+var ACTIVITY_METADATA = Object.freeze([
+  commandMetadata("activity list", {
+    description: `One page of operational activity, newest first: what the platform looked at, what it decided, and what failed. The filters are the ones the route keeps and no others: --cursor, --limit, --outcome (${ACTIVITY_OUTCOMES.join(", ")}), --repo, and the inclusive UTC dates --from and --to. A range or an outcome the server does not keep is refused here, before anything is read. A site nothing has happened on answers an empty page, which is not a read that failed.`,
+    target: { arguments: [{ name: "site-id", required: false, description: "The site to read. Defaults to the site the credential resolves to." }] },
+    effect: "Nothing. One read of one page of the activity log.",
+    output: { fields: ["site_id", "events", "next_cursor"], ids: [], limitations: ["page_bounded"] },
+    errors: ["invalid_input", "unauthorized", "forbidden", "not_found", "rate_limited", "service_unavailable", "transport_failure", "interrupted"],
+    examples: [
+      { command: "saturndocs activity list", description: "The newest page of activity for the credential's site." },
+      { command: "saturndocs activity list --outcome failed --from 2026-09-01 --to 2026-09-18", description: "Only the work that failed, over an inclusive UTC range." },
+      { command: 'saturndocs activity list --cursor "2026-09-18T11:00:00.000Z|job-published" --json', description: "The next page, from the previous answer's next_cursor." }
+    ]
+  }),
+  commandMetadata("activity get", {
+    description: "One job by id, read through the activity route's job_id filter rather than by scanning page one, so a job that queued before a hundred later events is still found. The answer keeps the job's progress, its outcome, its failure, and the suggestion, release, and pull request it is linked to. A job this site does not have is reported as not found; a job whose own work failed is a read that succeeded and exits 0.",
+    target: { arguments: [{ name: "job-id", required: true, description: "The job to read, as the server minted it." }] },
+    effect: "Nothing. One filtered read of the activity log.",
+    output: { fields: ["site_id", "job_id", "event"], ids: ["job_id", "suggestion_id", "release_id", "pr_number"], limitations: [] },
+    errors: ["invalid_input", "unauthorized", "forbidden", "not_found", "rate_limited", "service_unavailable", "transport_failure", "interrupted"],
+    examples: [
+      { command: "saturndocs activity get job-example --site acme --json", description: "One job as a result object, with its durable identities in the envelope." },
+      { command: "saturndocs activity get job-example", description: "The same read as a line of text." }
+    ]
+  })
+]);
+function wholeNumber(value) {
+  return Number(value);
+}
+function activityLimitations(page, requestedLimit) {
+  const limitations = [];
+  if (page.next_cursor !== null) {
+    limitations.push({
+      code: "page_bounded",
+      message: `This is one page of the activity log, not the site's whole history. Read the next page with --cursor ${page.next_cursor}.`,
+      at: "events"
+    });
+  }
+  if (requestedLimit !== void 0 && requestedLimit > ACTIVITY_LIMIT_CEILING) {
+    limitations.push({
+      code: "page_bounded",
+      message: `The server returns at most ${ACTIVITY_LIMIT_CEILING} events per page, so --limit ${requestedLimit} was answered with that many at most.`,
+      at: "events"
+    });
+  }
+  return limitations;
+}
+function eventLine(event) {
+  const parts = [`${event.created_at}  ${event.id}  ${event.operation}  ${event.state}`];
+  if (event.skip_reason != null) parts.push(`skipped ${event.skip_reason}`);
+  if (event.outcome_code !== null) parts.push(event.outcome_code);
+  if (event.error_code !== null) parts.push(`failed ${event.error_code}`);
+  if (event.repository !== null) parts.push(event.repository);
+  if (event.suggestion_id !== null) parts.push(`suggestion ${event.suggestion_id}`);
+  if (event.pr_number !== null) parts.push(`pr ${event.pr_number}`);
+  if (event.release != null) parts.push(`release ${event.release.release_id}`);
+  return parts.join("  ");
+}
+function listText(page) {
+  if (page.events.length === 0) {
+    return `${page.site_id}: no activity matched. That is an answer, not a failed read.`;
+  }
+  const tail = page.next_cursor === null ? "End of the log for these filters." : `More activity follows: --cursor ${page.next_cursor}`;
+  return [...page.events.map(eventLine), tail].join("\n");
+}
+function jobText(read) {
+  const event = read.event;
+  const lines = [
+    `job: ${event.id}`,
+    `site: ${read.site_id}`,
+    `operation: ${event.operation}`,
+    `state: ${event.state}${event.outcome_code === null ? "" : ` (${event.outcome_code})`}`,
+    `started: ${event.created_at}, last change ${event.updated_at}`,
+    event.error_code === null ? "failure: none" : `failure: ${event.error_code}${event.error_message === null ? "" : ` \u2014 ${event.error_message}`}`,
+    `repository: ${event.repository ?? "none recorded"}`,
+    `suggestion: ${event.suggestion_id ?? "none"}`,
+    `pull request: ${event.pr_number === null ? "none" : String(event.pr_number)}`,
+    `release: ${event.release == null ? "none" : event.release.release_id}`
+  ];
+  if (event.skip_reason != null) lines.push(`skipped: ${event.skip_reason}`);
+  if (event.reason != null) lines.push(`reason: ${event.reason}`);
+  return lines.join("\n");
+}
+function identitiesOf(event) {
+  const ids = { job_id: event.id };
+  if (event.suggestion_id !== null) ids.suggestion_id = event.suggestion_id;
+  if (event.pr_number !== null) ids.pr_number = event.pr_number;
+  if (event.release != null) ids.release_id = event.release.release_id;
+  return ids;
+}
+function registerActivity(program, _cliDir, environment = {}) {
+  const activity = program.command("activity").description("Read what the platform did, and one job by id");
+  const list = activity.command("list").argument("[site-id]", "The site to read. Defaults to the site the credential resolves to.").option("--limit <n>", `Events per page, up to the server's ceiling of ${ACTIVITY_LIMIT_CEILING}.`, wholeNumber).action(async (siteId, options, self) => {
+    const globals = resolveGlobalOptions(self);
+    const writer = createResultWriter({ json: globals.json });
+    const context = { command: "activity list", siteId: null };
+    try {
+      const client = clientFor(globals, environment);
+      const named = requestedSite(siteId, globals.site);
+      const target = await resolveTarget(client, named === void 0 ? {} : { site: named });
+      context.siteId = target.site_id;
+      const page = await listActivity(client, target.site_id, options);
+      context.limitations = activityLimitations(page, options.limit);
+      process.exitCode = writer.write(successResult(context, page), { text: listText(page) });
+    } catch (error) {
+      process.exitCode = writer.write(failureResult(asCliError(error), context));
+    }
+  });
+  applyCommandHelp(list, ACTIVITY_METADATA[0]);
+  const get = activity.command("get").argument("<job-id>", "The job to read, as the server minted it.").action(async (jobId, _options, self) => {
+    const globals = resolveGlobalOptions(self);
+    const writer = createResultWriter({ json: globals.json });
+    const context = { command: "activity get", siteId: null };
+    try {
+      const client = clientFor(globals, environment);
+      const target = await resolveTarget(client, globals.site === null ? {} : { site: globals.site });
+      context.siteId = target.site_id;
+      const read = await readActivityJob(client, target.site_id, jobId);
+      if (!activityJobFound(read)) {
+        throw new CliError("not_found", `${target.site_id} has no job ${jobId}. The server answered with no events, which is this site not having that job rather than a read that failed.`);
+      }
+      context.ids = identitiesOf(read.event);
+      process.exitCode = writer.write(successResult(context, read), { text: jobText(read) });
+    } catch (error) {
+      process.exitCode = writer.write(failureResult(asCliError(error), context));
+    }
+  });
+  applyCommandHelp(get, ACTIVITY_METADATA[1]);
+}
+export {
+  ACTIVITY_METADATA,
+  activityLimitations,
+  registerActivity
+};

package/dist/read-ZEVUZNNB.js

@@ -0,0 +1,146 @@
+import {
+  requestedSite
+} from "./chunk-CMNX5DLQ.js";
+import {
+  asCliError,
+  clientFor
+} from "./chunk-TKISMN3P.js";
+import "./chunk-KGJESHJC.js";
+import {
+  applyCommandHelp
+} from "./chunk-M2BZEDAS.js";
+import {
+  RELEASE_PAGE_MAX,
+  activeStatusOf,
+  classifyReleaseActivation,
+  commandMetadata,
+  createResultWriter,
+  failureResult,
+  getRelease,
+  listReleases,
+  resolveGlobalOptions,
+  resolveTarget,
+  successResult
+} from "./chunk-GYRVGWDM.js";
+
+// src/commands/releases/read.ts
+import { InvalidArgumentError } from "commander";
+var RELEASES_METADATA = Object.freeze([
+  commandMetadata("releases list", {
+    description: "Read one page of this site's releases, newest first, with when each one was built, what it was built from, the job behind it, and its activation record. The answer also carries which release the site is serving and whether that could be read at all: active_release_status unknown means the activation store did not answer, which is not the same as the site having no active release.",
+    target: { arguments: [{ name: "site-id", required: false, description: "The site to read. Defaults to the site the credential resolves to." }] },
+    effect: "Nothing. One read of the release listing.",
+    output: { fields: ["site_id", "active_release_id", "active_release_status", "releases", "next_cursor"], ids: ["release_id"], limitations: ["page_bounded", "activation_unknown"] },
+    errors: ["invalid_input", "unauthorized", "forbidden", "not_found", "rate_limited", "service_unavailable", "transport_failure", "interrupted"],
+    examples: [
+      { command: "saturndocs releases list", description: "The newest page of releases and what the site is serving." },
+      { command: "saturndocs releases list --limit 10", description: "A smaller page, within the route's ceiling of 50." },
+      { command: "saturndocs releases list --cursor <next_cursor> --json", description: "The page after the one whose next_cursor this is." }
+    ]
+  }),
+  commandMetadata("releases get", {
+    description: "Read one release by id through the listing's release_id filter, so a release older than the first page is found without paging to it. The release is reported as live, historical, or built: a release with no activation record was never published, and a release that was activated but is not the active one is history. An empty answer is that id not being this site's, and never a claim about which release is active.",
+    target: { arguments: [{ name: "release-id", required: true, description: "The release to read, as release_id." }] },
+    effect: "Nothing. One filtered read of the release listing.",
+    output: { fields: ["site_id", "release", "activation", "page"], ids: ["release_id", "job_id"], limitations: ["activation_unknown"] },
+    errors: ["invalid_input", "unauthorized", "forbidden", "not_found", "rate_limited", "service_unavailable", "transport_failure", "interrupted"],
+    examples: [
+      { command: "saturndocs releases get old-release --site acme", description: "One release by id, including one built long before the newest page." },
+      { command: "saturndocs releases get old-release --json", description: "The release, its activation, and the answer it came from as one result object." }
+    ]
+  })
+]);
+function pageSize(value) {
+  const limit = Number(value);
+  if (!Number.isInteger(limit) || limit < 1 || limit > RELEASE_PAGE_MAX) {
+    throw new InvalidArgumentError(`--limit takes a whole number from 1 to ${RELEASE_PAGE_MAX}; the route refuses anything else rather than trimming it.`);
+  }
+  return limit;
+}
+var UNKNOWN_ACTIVATION = {
+  code: "activation_unknown",
+  message: "The activation store did not answer, so which release readers are seeing could not be read. active_release_id null here means unread, not that the site has no active release.",
+  at: "active_release_id"
+};
+function releaseLimitations(page) {
+  const limitations = [];
+  if (activeStatusOf(page) === "unknown") limitations.push(UNKNOWN_ACTIVATION);
+  if (page.next_cursor !== null) {
+    limitations.push({
+      code: "page_bounded",
+      message: "This is one page of releases. Older releases remain behind next_cursor; read an exact one with releases get rather than paging to it.",
+      at: "releases"
+    });
+  }
+  return limitations;
+}
+function activeLine(page) {
+  if (activeStatusOf(page) === "unknown") return "active release: unknown \u2014 the activation record could not be read";
+  return page.active_release_id === null ? "active release: none reported" : `active release: ${page.active_release_id}`;
+}
+function listText(page) {
+  const rows = page.releases.map((release) => {
+    const activation = classifyReleaseActivation(release, page);
+    return `${release.release_id}  ${release.state}  built ${release.built_at}  ${activation.state}  job ${release.job.job_id}`;
+  });
+  const tail = page.next_cursor === null ? "end of the listing" : `more releases behind cursor ${page.next_cursor}`;
+  return [`${page.site_id}: ${page.releases.length} releases on this page`, activeLine(page), ...rows, tail].join("\n");
+}
+function getText(result) {
+  const { release, activation } = result;
+  return [
+    `release: ${release.release_id} (${release.state})`,
+    `built: ${release.built_at} from ${release.source_revision_id}${release.git_commit === null ? "" : ` at ${release.git_commit}`}`,
+    `digest: ${release.digest ?? "not recorded"}`,
+    `job: ${release.job.job_id}${release.job.operation === null ? "" : ` (${release.job.operation})`}${release.job.requested_by === null ? "" : ` requested by ${release.job.requested_by}`}`,
+    `activation: ${activation.state} \u2014 ${activation.summary}`,
+    activeLine(result.page)
+  ].join("\n");
+}
+function registerReleases(program, _cliDir, environment = {}) {
+  const releases = program.command("releases").description("Read this site's release history and one release by id");
+  const list = releases.command("list").argument("[site-id]", "The site to read. Defaults to the site the credential resolves to.").option("--limit <n>", `Page size, from 1 to ${RELEASE_PAGE_MAX}.`, pageSize).action(async (siteId, options, self) => {
+    const globals = resolveGlobalOptions(self);
+    const writer = createResultWriter({ json: globals.json });
+    const context = { command: "releases list", siteId: null };
+    try {
+      const client = clientFor(globals, environment);
+      const named = requestedSite(siteId, globals.site);
+      const target = await resolveTarget(client, named === void 0 ? {} : { site: named });
+      context.siteId = target.site_id;
+      const page = await listReleases(client, target.site_id, {
+        ...options.limit === void 0 ? {} : { limit: options.limit },
+        ...options.cursor === void 0 ? {} : { cursor: options.cursor }
+      });
+      context.limitations = releaseLimitations(page);
+      if (page.active_release_id !== null && activeStatusOf(page) === "known") context.ids = { release_id: page.active_release_id };
+      process.exitCode = writer.write(successResult(context, page), { text: listText(page) });
+    } catch (error) {
+      process.exitCode = writer.write(failureResult(asCliError(error), context));
+    }
+  });
+  applyCommandHelp(list, RELEASES_METADATA[0]);
+  const get = releases.command("get").argument("<release-id>", "The release to read, as release_id.").action(async (releaseId, _options, self) => {
+    const globals = resolveGlobalOptions(self);
+    const writer = createResultWriter({ json: globals.json });
+    const context = { command: "releases get", siteId: null };
+    try {
+      const client = clientFor(globals, environment);
+      const target = await resolveTarget(client, globals.site === null ? {} : { site: globals.site });
+      context.siteId = target.site_id;
+      context.ids = { release_id: releaseId };
+      const result = await getRelease(client, target.site_id, releaseId);
+      context.limitations = releaseLimitations(result.page);
+      context.ids = { release_id: result.release.release_id, job_id: result.release.job.job_id };
+      process.exitCode = writer.write(successResult(context, result), { text: getText(result) });
+    } catch (error) {
+      process.exitCode = writer.write(failureResult(asCliError(error), context));
+    }
+  });
+  applyCommandHelp(get, RELEASES_METADATA[1]);
+}
+export {
+  RELEASES_METADATA,
+  registerReleases,
+  releaseLimitations
+};

package/dist/requests-H5MIGBIS.js

@@ -0,0 +1,13 @@
+import {
+  REQUESTS_METADATA,
+  registerRequests
+} from "./chunk-U7PKMSB3.js";
+import "./chunk-N7QPZMLP.js";
+import "./chunk-TKISMN3P.js";
+import "./chunk-KGJESHJC.js";
+import "./chunk-M2BZEDAS.js";
+import "./chunk-GYRVGWDM.js";
+export {
+  REQUESTS_METADATA,
+  registerRequests
+};

package/dist/schema-XJUEZSIW.js

@@ -0,0 +1,13 @@
+import {
+  SCHEMA_METADATA,
+  registerSchema,
+  schemaDocument
+} from "./chunk-5KX4ZK5E.js";
+import "./chunk-QLFODLVN.js";
+import "./chunk-M2BZEDAS.js";
+import "./chunk-GYRVGWDM.js";
+export {
+  SCHEMA_METADATA,
+  registerSchema,
+  schemaDocument
+};

package/dist/sites-I4WI2MPG.js

@@ -0,0 +1,14 @@
+import {
+  SITES_METADATA,
+  registerSites,
+  requestedSite
+} from "./chunk-CMNX5DLQ.js";
+import "./chunk-TKISMN3P.js";
+import "./chunk-KGJESHJC.js";
+import "./chunk-M2BZEDAS.js";
+import "./chunk-GYRVGWDM.js";
+export {
+  SITES_METADATA,
+  registerSites,
+  requestedSite
+};

package/dist/status-7R3NOI5H.js

@@ -0,0 +1,14 @@
+import {
+  STATUS_METADATA,
+  registerStatus,
+  statusText
+} from "./chunk-3V753MRI.js";
+import "./chunk-TKISMN3P.js";
+import "./chunk-KGJESHJC.js";
+import "./chunk-M2BZEDAS.js";
+import "./chunk-GYRVGWDM.js";
+export {
+  STATUS_METADATA,
+  registerStatus,
+  statusText
+};