@scalar/cli 2.0.1 → 2.5.1

package/chunks/chunk-PT5TI77I.js

@@ -0,0 +1,34 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  BaseCollections
+} from "./chunk-F467BYYR.js";
+import {
+  getDatabaseClient
+} from "./chunk-Z2KMGFE6.js";
+import {
+  publishRecordSchema
+} from "./chunk-OQKDBLOZ.js";
+
+// src/domains/project/deployments/get-deployments.ts
+function orderDeployments(records) {
+  return records.filter((record) => !record.preview).sort((a, b) => b.createdAt - a.createdAt);
+}
+async function getProjectDeployments({
+  teamUid,
+  projectUid
+}) {
+  const client = await getDatabaseClient();
+  const result = await client.getMany({
+    collectionPath: BaseCollections.PublishRecords(teamUid),
+    query: { projectUid },
+    schema: publishRecordSchema.array()
+  });
+  if (result.error) {
+    return { success: false, error: result.message };
+  }
+  return { success: true, deployments: orderDeployments(result.data) };
+}
+
+export {
+  getProjectDeployments
+};

package/chunks/chunk-Q7DOQHZN.js

@@ -0,0 +1,404 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  methodSchema
+} from "./chunk-GSGZHE26.js";
+import {
+  brandedUid,
+  docVersionSchema,
+  entitySchema,
+  external_exports,
+  mintUid,
+  namespaceSchema,
+  nanoidSchema,
+  randomManagedDocSlug,
+  scalarSet,
+  slugSchema,
+  timestampSchema
+} from "./chunk-IKT5F47M.js";
+
+// ../../packages/entities/dist/registry/instance.js
+var contentShaSchema = external_exports.string().regex(/^[a-f0-9]{64}$/, "Content sha must be a sha-256 hex digest");
+var docInstanceSourceSchema = external_exports.enum(["manual", "cli", "api", "git-sync", "url-sync", "migration"]).meta({ id: "doc-instance-source" });
+var docInstanceOriginSchema = external_exports.discriminatedUnion("type", [
+  external_exports.object({ type: external_exports.literal("platform") }),
+  external_exports.object({
+    type: external_exports.literal("git"),
+    /**
+     * Commit that carried this content. Null when the content landed but the
+     * commit did not — the mirror is best-effort and can be switched off.
+     */
+    commitSha: external_exports.string().nullable().default(null),
+    /** Branch this content was committed on. Null for direct-to-published writes. */
+    branch: external_exports.string().nullable().default(null),
+    /**
+     * A platform edit to a git-sourced document that went out as a pull
+     * request. Open while `resolution` is null; the webhook stamps `merged`
+     * or `closed` when the pull request settles, so "does this document have
+     * an open proposal" is answerable from the log alone. The row itself is
+     * append-only history — a merged proposal's content re-enters the log as
+     * a fresh instance via the merge push.
+     */
+    draft: external_exports.object({
+      prNumber: external_exports.number(),
+      branch: external_exports.string(),
+      /** How the pull request settled; null while it is still open. */
+      resolution: external_exports.enum(["merged", "closed"]).nullable().default(null)
+    }).nullable().default(null)
+  }),
+  external_exports.object({
+    type: external_exports.literal("url"),
+    /** Upstream this content was fetched from. */
+    url: external_exports.url()
+  })
+]).meta({ id: "doc-instance-origin" });
+var docInstanceSchema = entitySchema.extend({
+  /** Own uid, branded so it cannot be confused with another entity's uid */
+  uid: brandedUid().default(mintUid).meta({ default: "nanoid()" }),
+  /** Version label the content declared (info.version) or the caller supplied */
+  version: docVersionSchema,
+  /**
+   * SHA-256 hex digest of the serialized JSON — the single content identity.
+   * Blob keys for BOTH formats derive from it: `blobs/<jsonSha>.json` and
+   * `blobs/<jsonSha>.yaml`.
+   */
+  jsonSha: contentShaSchema,
+  /**
+   * SHA-256 hex digest of the serialized YAML twin. Integrity metadata for
+   * verifying served YAML bytes — never a storage key.
+   */
+  yamlSha: contentShaSchema,
+  /** User uid or email that produced this content. Null for system syncs. */
+  uploadedBy: external_exports.string().nullable().default(null),
+  /** The channel that triggered the write */
+  source: docInstanceSourceSchema,
+  /** Where the bytes came from; platform-native unless a git or url source supplied them */
+  origin: docInstanceOriginSchema.default({ type: "platform" }),
+  /** Free-form commit-style message supplied by the writer */
+  message: external_exports.string().default(""),
+  /**
+   * Lineage pointers recorded from day one so instances form a DAG. Branch
+   * and merge flows build on this; backfilling parents later would be far
+   * more expensive than stamping them now.
+   */
+  parentInstanceUid: brandedUid().nullable().default(null),
+  /** Second parent for merge commits */
+  mergeParentUid: brandedUid().nullable().default(null),
+  /**
+   * The instance this one reverts to. Set only by rollback, which appends a
+   * new instance carrying the target's content hashes rather than mutating
+   * any pointer — so history renders "reverted to X" without diffing hashes,
+   * and the chain stays append-only.
+   */
+  revertOf: brandedUid().nullable().default(null),
+  /**
+   * Denormalized serving eligibility, stamped false only on draft instances.
+   * Exists solely for the chain's unique-parent index: Mongo partial indexes
+   * cannot express "origin.draft is null or missing", so eligibility needs a
+   * stored equality field. {@link isServingEligibleInstance} (origin-derived)
+   * stays the read-side authority; this field is never read by resolvers.
+   */
+  servable: external_exports.boolean().default(true)
+}).meta({ id: "doc-instance" });
+
+// ../../packages/entities/dist/registry/schema.js
+var RegistryAsset;
+(function(RegistryAsset2) {
+  RegistryAsset2["Apis"] = "apis";
+  RegistryAsset2["Rules"] = "rules";
+  RegistryAsset2["Schemas"] = "schemas";
+  RegistryAsset2["Sdks"] = "sdks";
+  RegistryAsset2["Workspaces"] = "workspaces";
+})(RegistryAsset || (RegistryAsset = {}));
+var RegistryResourceTypes = [
+  RegistryAsset.Apis,
+  RegistryAsset.Schemas,
+  RegistryAsset.Rules,
+  RegistryAsset.Sdks,
+  RegistryAsset.Workspaces
+];
+var registryAssetSchema = external_exports.enum(RegistryAsset).meta({ id: "registry-asset" });
+var registryGitExternalSchema = external_exports.discriminatedUnion("provider", [
+  external_exports.object({
+    provider: external_exports.literal("github"),
+    linkedBy: external_exports.string(),
+    installationId: external_exports.number().int(),
+    id: external_exports.number().int(),
+    name: external_exports.string().min(2),
+    branch: external_exports.string().default("main"),
+    /** Where the canonical file lives inside the linked repo. */
+    path: external_exports.string().default(""),
+    webhookId: external_exports.string().default("")
+  }),
+  external_exports.object({
+    provider: external_exports.literal("bitbucket"),
+    linkedBy: external_exports.string(),
+    workspaceUuid: external_exports.string(),
+    workspaceSlug: external_exports.string(),
+    repoUuid: external_exports.string(),
+    repoSlug: external_exports.string(),
+    name: external_exports.string().min(2),
+    branch: external_exports.string().default("main"),
+    webhookUuid: external_exports.string().default("")
+  })
+]).meta({ id: "registry-git-external" });
+var registryGitBindingSchema = external_exports.object({
+  forgejo: external_exports.object({
+    owner: external_exports.string(),
+    repo: external_exports.string(),
+    branch: external_exports.string().default("main")
+  }),
+  /** Publish when a commit lands on the tracked branch. */
+  publishOnPush: external_exports.boolean().default(true),
+  /** Publish when a pull request is merged. */
+  publishOnMerge: external_exports.boolean().default(false),
+  trackedBranch: external_exports.string().default("main"),
+  /** Forgejo webhook id, so it can be updated or removed. */
+  webhookId: external_exports.number().nullable().default(null),
+  external: registryGitExternalSchema.nullable().default(null),
+  /** The commit currently served as the published state. */
+  currentPublishedSha: external_exports.string().nullable().default(null),
+  lastPublishedAt: timestampSchema.nullable().default(null)
+}).meta({ id: "registry-git-binding" });
+var docSourceSchema = external_exports.discriminatedUnion("type", [
+  external_exports.object({ type: external_exports.literal("platform") }),
+  external_exports.object({
+    type: external_exports.literal("git"),
+    /** The team's linked repository this document sources from. */
+    repositoryUid: nanoidSchema.brand(),
+    /** Where the canonical file lives inside the repository. */
+    path: external_exports.string().min(1),
+    /**
+     * The branch publishes track and pull requests target. Null follows the
+     * repository's default branch.
+     */
+    branch: external_exports.string().nullable().default(null),
+    /** Publish when a commit lands on the tracked branch. */
+    publishOnPush: external_exports.boolean().default(true),
+    /** Publish when a pull request merges into the tracked branch. */
+    publishOnMerge: external_exports.boolean().default(false),
+    /**
+     * The commit currently served as the published state. Advanced by
+     * compare-and-swap so redelivered webhooks and racing publishes cannot
+     * interleave the publish log and the pointer.
+     */
+    currentPublishedSha: external_exports.string().nullable().default(null),
+    lastPublishedAt: timestampSchema.nullable().default(null)
+  }),
+  external_exports.object({
+    type: external_exports.literal("url"),
+    url: external_exports.url(),
+    linkedBy: external_exports.string(),
+    /** ETag from the last fetch so refreshes can use If-None-Match */
+    etag: external_exports.string().nullable().default(null),
+    lastFetchedAt: timestampSchema.nullable().default(null)
+  })
+]).meta({ id: "doc-source" });
+var baseRegistrySchema = entitySchema.extend({
+  /** Team namespace - not linked by UID */
+  namespace: namespaceSchema,
+  /** UI label for registry item */
+  title: external_exports.string().max(100).default(""),
+  /** Unique configuration identifier */
+  slug: slugSchema.default(randomManagedDocSlug).meta({ default: "randomManagedDocSlug()" }),
+  /** Extended description for registry item */
+  description: external_exports.string().default(""),
+  /** Public accessibility */
+  isPrivate: external_exports.boolean().default(false),
+  /**
+   * Surfaced ahead of the rest of the list on the namespace's registry page.
+   * A record only ever belongs to one namespace, so this needs no target.
+   */
+  pinned: external_exports.boolean().default(false),
+  /** Grouping/identifier tags */
+  tags: scalarSet(external_exports.set(external_exports.string()).max(100)).default([]),
+  /** Access groups for private access permissions */
+  accessGroups: scalarSet(external_exports.set(nanoidSchema).max(50)).default([]),
+  /** The uid of the login portal customization object for private documents */
+  loginPortalUid: external_exports.string().optional(),
+  /** Whether the content has been scanned and confirmed to not to contain malicious content */
+  verifiedContent: external_exports.boolean().optional(),
+  /**
+   * Where this document's content is authored. Records written before this
+   * field existed omit it and read back as platform-native.
+   *
+   * Kept a plain `.default()` rather than a `.nullish().transform()` that
+   * would also absorb a stored `null`: the API framework drops piped fields
+   * from generated response types, so a transform here erases `source` from
+   * every registry response. Nothing writes `null`, so write it as `undefined`
+   * (omit the field) rather than reintroducing the pipe.
+   */
+  source: docSourceSchema.default({ type: "platform" }),
+  /**
+   * @deprecated Forgejo registry backing is being retired in favor of
+   * content-addressed GCS blobs + the instance log. Use `source` for the
+   * external-repo link. Dropped once the backfill is verified.
+   */
+  git: registryGitBindingSchema.nullable().optional()
+}).meta({ id: "base-registry" });
+
+// ../../packages/entities/dist/registry/migration.js
+var registryGitMigrationResourceSchema = external_exports.object({
+  asset: registryAssetSchema,
+  namespace: namespaceSchema,
+  slug: slugSchema,
+  resourceUid: nanoidSchema,
+  status: external_exports.enum([
+    "migrated",
+    "already-migrated",
+    "partial",
+    "would-migrate",
+    "error"
+  ]),
+  versionsImported: external_exports.number().default(0),
+  versionsSkipped: external_exports.number().default(0),
+  error: external_exports.string().default("")
+});
+var registryGitMigrationStatusSchema = external_exports.enum([
+  "running",
+  "complete",
+  "partial",
+  "failed"
+]);
+var registryGitMigrationSchema = entitySchema.extend({
+  teamUid: brandedUid(),
+  dryRun: external_exports.boolean().default(false),
+  status: registryGitMigrationStatusSchema,
+  /**
+   * While `running`, the unix time after which the lease is considered
+   * abandoned and another run may take over. Renewed as the run progresses, so
+   * it only lapses when the run really stopped (a crash, a killed pod) rather
+   * than because the work took a while. Zero once the run has finished.
+   */
+  lockedUntil: external_exports.number().default(0),
+  resources: registryGitMigrationResourceSchema.array().default([])
+}).meta({ id: "registry-git-migration" });
+
+// ../../packages/entities/dist/registry/publish.js
+var registryPublishSourceSchema = external_exports.enum(["manual", "git-hook", "external-push", "migration"]).meta({ id: "registry-publish-source" });
+var registryPublishAuthorSchema = external_exports.object({
+  name: external_exports.string(),
+  email: external_exports.string()
+});
+var registryPublishRecordSchema = entitySchema.extend({
+  resourceUid: nanoidSchema,
+  asset: registryAssetSchema,
+  namespace: namespaceSchema,
+  slug: slugSchema,
+  /** Null for unversioned resources (rules). */
+  version: docVersionSchema.nullable().default(null),
+  commitSha: external_exports.string(),
+  parentSha: external_exports.string().nullable().default(null),
+  source: registryPublishSourceSchema,
+  message: external_exports.string().default(""),
+  author: registryPublishAuthorSchema.nullable().default(null)
+}).meta({ id: "registry-publish" });
+
+// ../../packages/entities/dist/registry/version.js
+var docVersionToolSchema = external_exports.object({
+  path: external_exports.string(),
+  method: methodSchema,
+  enabledTools: external_exports.enum(["execute-request", "get-mini-openapi-spec"]).array()
+});
+var docEmbedStatusSchema = external_exports.enum(["complete", "failed"]);
+var docVersionRecordSchema = entitySchema.extend({
+  /** Own uid, branded so it cannot be confused with another entity's uid */
+  uid: brandedUid().default(mintUid).meta({ default: "nanoid()" }),
+  version: docVersionSchema,
+  /** OpenAPI version normalized on upload */
+  upgraded: external_exports.boolean().default(false),
+  /**
+   * Endpoints (path + method pairs) counted from the document at ingest.
+   * Null when the count is unknown: rows minted before this field existed,
+   * heal-path rows created without a fresh parse, and non-OpenAPI documents.
+   * Feeds the included-SDK-size display; measure-and-warn only.
+   */
+  endpointCount: external_exports.number().int().nullable().default(null),
+  embedStatus: docEmbedStatusSchema.nullable().default(null),
+  tags: external_exports.string().array().default([]),
+  /**
+   * Null is a legitimate stored state, not just absence: zod keeps optional
+   * keys explicitly passed as `undefined`, and a driver without
+   * `ignoreUndefined` stores those as BSON null. Records written that way
+   * carry `tools: null`, and rejecting it silently drops the whole record
+   * from egress — so null parses like "no tools configured".
+   */
+  tools: docVersionToolSchema.array().nullish()
+}).meta({ id: "doc-version-record" });
+
+// ../../packages/entities/dist/registry/pages.js
+var PAGES_SCHEMA_VERSION = 1;
+var pagesNavigationEntrySchema = external_exports.looseObject({
+  id: external_exports.string(),
+  title: external_exports.string().default(""),
+  type: external_exports.string(),
+  get children() {
+    return external_exports.array(pagesNavigationEntrySchema).optional();
+  }
+});
+var pagesEntrySchema = external_exports.object({
+  /** The navigation entry's `type`, e.g. `operation`, `webhook`, `model`. */
+  type: external_exports.string(),
+  method: external_exports.string().optional(),
+  path: external_exports.string().optional(),
+  /** JSON pointer the entry renders, for the entry types that carry one. */
+  ref: external_exports.string().optional()
+}).meta({ id: "pages-entry" });
+var pagesCountsSchema = external_exports.object({
+  operations: external_exports.number().int().min(0).default(0),
+  webhooks: external_exports.number().int().min(0).default(0),
+  models: external_exports.number().int().min(0).default(0),
+  tags: external_exports.number().int().min(0).default(0),
+  /** Objects written under `chunks/`, which is every entry with a page. */
+  chunks: external_exports.number().int().min(0).default(0)
+}).meta({ id: "pages-counts" });
+var pagesManifestSchema = external_exports.object({
+  schemaVersion: external_exports.literal(PAGES_SCHEMA_VERSION),
+  /** Content identity of the instance this sidecar was derived from. */
+  jsonSha: contentShaSchema,
+  producedAt: timestampSchema,
+  counts: pagesCountsSchema,
+  /**
+   * The document with its operation-bearing buckets emptied — the base every
+   * page starts from, before its own chunk is merged in.
+   */
+  stripped: external_exports.record(external_exports.string(), external_exports.unknown()),
+  /**
+   * The navigation tree, with the Models group's children dropped: a large
+   * document has thousands of them, and they are served separately by
+   * `pagesModels` on first expand.
+   */
+  navigation: external_exports.array(pagesNavigationEntrySchema),
+  /** Navigation id to what it renders, for routing without walking the tree. */
+  entries: external_exports.record(external_exports.string(), pagesEntrySchema)
+}).meta({ id: "pages-manifest" });
+var pagesPreparingSchema = external_exports.object({
+  jsonSha: contentShaSchema,
+  claimedAt: timestampSchema,
+  /** Which producer holds the claim, so a stale takeover is attributable. */
+  instance: external_exports.string().default("")
+}).meta({ id: "pages-preparing" });
+var pagesFailedSchema = external_exports.object({
+  jsonSha: contentShaSchema,
+  failedAt: timestampSchema,
+  /** Operator-facing reason; surfaced to the client only as a failure. */
+  error: external_exports.string().default("")
+}).meta({ id: "pages-failed" });
+
+// ../../packages/entities/dist/registry/token.js
+var registryTokenPayloadSchema = external_exports.object({
+  /** The team whose registry documents this token may read. */
+  teamUid: nanoidSchema,
+  exp: external_exports.number().int()
+}).meta({ id: "registry-token-payload" });
+
+export {
+  contentShaSchema,
+  docInstanceSchema,
+  RegistryResourceTypes,
+  registryGitBindingSchema,
+  docSourceSchema,
+  baseRegistrySchema,
+  registryPublishRecordSchema,
+  docVersionToolSchema,
+  docVersionRecordSchema
+};

package/chunks/chunk-T5HJUAWB.js

@@ -0,0 +1,242 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+
+// src/helpers/std-out/print-table.ts
+import { Table } from "console-table-printer";
+var printTable = (columns, rows) => {
+  const table2 = new Table({ columns });
+  for (const row of rows) {
+    table2.addRow(row);
+  }
+  table2.printTable();
+};
+
+// src/helpers/std-out/output.ts
+import as from "ansis";
+import UpdateManager from "stdout-update";
+
+// ../../node_modules/.pnpm/ansi-regex@6.2.2/node_modules/ansi-regex/index.js
+function ansiRegex({ onlyFirst = false } = {}) {
+  const ST = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
+  const osc = `(?:\\u001B\\][\\s\\S]*?${ST})`;
+  const csi = "[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]";
+  const pattern = `${osc}|${csi}`;
+  return new RegExp(pattern, onlyFirst ? void 0 : "g");
+}
+
+// ../../node_modules/.pnpm/strip-ansi@7.2.0/node_modules/strip-ansi/index.js
+var regex = ansiRegex();
+function stripAnsi(string) {
+  if (typeof string !== "string") {
+    throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
+  }
+  if (!string.includes("\x1B") && !string.includes("\x9B")) {
+    return string;
+  }
+  return string.replace(regex, "");
+}
+
+// src/helpers/std-out/table.ts
+var table = (data, options) => {
+  let maxCols = 0;
+  data.forEach((row) => {
+    if (row.length > maxCols) {
+      maxCols = row.length;
+    }
+  });
+  const maxLengths = new Array(maxCols).fill(0);
+  for (const i of data.keys()) {
+    for (const j of data[i].keys()) {
+      if (stripAnsi(data[i][j]).length > maxLengths[j]) {
+        maxLengths[j] = stripAnsi(data[i][j]).length;
+      }
+    }
+  }
+  for (const row of data) {
+    for (const [index, col] of row.entries()) {
+      const lengthDiff = col.length - stripAnsi(col).length;
+      row[index] = col.padEnd(
+        maxLengths[index] + (options?.padding ?? 1) + lengthDiff
+      );
+    }
+  }
+};
+
+// src/helpers/std-out/output.ts
+var levelColors = {
+  info: (s) => s,
+  warn: as.yellow,
+  error: as.red
+};
+var levelPrefixes = {
+  info: "",
+  warn: "[WARN]",
+  error: "[ERROR]"
+};
+var stdoutManager;
+var stderrManager;
+function getManager(level) {
+  if (level === "error") {
+    if (!stderrManager) {
+      stderrManager = new UpdateManager(process.stderr, process.stderr);
+    }
+    return stderrManager;
+  }
+  if (!stdoutManager) {
+    stdoutManager = new UpdateManager(
+      process.stdout,
+      process.stdout
+    );
+  }
+  return stdoutManager;
+}
+var outputFactory = (level) => (options) => {
+  const titlePrefix = levelPrefixes[level];
+  const cl = levelColors[level];
+  const manager = getManager(level);
+  const stream = level === "error" ? process.stderr : process.stdout;
+  const state = [];
+  let i = 0;
+  const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  function update(complete) {
+    i += 1;
+    manager.update(
+      state.map((it) => {
+        if (it.type === "title") {
+          return cl(as.bold(`${titlePrefix} ${it.content}`));
+        }
+        if (it.type === "loader") {
+          if (!complete) {
+            return cl(`${frames[i % frames.length]} ${it.content}`);
+          }
+          return it.status === "error" ? as.red(`\u2716 ${it.content}`) : cl(`\u2714 ${it.content}`);
+        }
+        if (it.type === "table") {
+          return it.content.map((it2) => cl(it2.join(""))).join("\n");
+        }
+        return cl(it.content);
+      })
+    );
+  }
+  manager.hook();
+  const interval = setInterval(() => {
+    update();
+  }, options?.frameRate ?? 100);
+  function end() {
+    update(true);
+    stream.write("");
+    manager.unhook();
+    clearInterval(interval);
+    return { state };
+  }
+  return {
+    /** Current list of std-out state objects */
+    state,
+    /** Display a formatted title */
+    title: function(title) {
+      state.push({
+        type: "title",
+        content: title
+      });
+      return this;
+    },
+    /** Display a new line with the provided content */
+    line: function(content) {
+      state.push({
+        type: "line",
+        content: content ?? ""
+      });
+      return this;
+    },
+    /** Display a message with a line above and below */
+    message: function(content) {
+      state.push(
+        {
+          type: "line",
+          content: ""
+        },
+        {
+          type: "line",
+          content: content ?? ""
+        },
+        {
+          type: "line",
+          content: ""
+        }
+      );
+      return this;
+    },
+    /** Display a loader with a message alongside. */
+    loader: function(content) {
+      state.push({
+        type: "loader",
+        content: content ?? ""
+      });
+      return this;
+    },
+    /**
+     * Update a specific line of a specific type
+     * Only works when animate is set to true
+     */
+    update: function(type, index, values) {
+      const operation = state.filter((it) => it.type === type)[index];
+      if (operation) {
+        Object.assign(operation, values);
+      }
+      if (operation.type === "table") {
+        table(operation.content, operation.options);
+      }
+      return this;
+    },
+    /**
+     * Delete a specific line of a specific type
+     * Only works when the animate is set to true
+     */
+    delete: function(type, index) {
+      let count = 0;
+      for (let i2 = 0; i2 < state.length; i2++) {
+        if (state[i2].type === type) {
+          if (count === index) {
+            state.splice(i2, 1);
+            return;
+          }
+          count++;
+        }
+      }
+      return this;
+    },
+    /** Display a table that handles padding column widths automatically */
+    table: function(data, opt) {
+      table(data, opt);
+      state.push({
+        type: "table",
+        content: data,
+        options: opt
+      });
+      return this;
+    },
+    /** Print the current state to the console */
+    print: end,
+    /**
+     * Finish a log block and unhook from the std-out manager
+     * This closes out a running animation
+     */
+    finish: end,
+    /** Exit the process with a success code */
+    exit: (code) => {
+      end();
+      return process.exit(code === "error" ? 1 : 0);
+    }
+  };
+};
+
+// src/helpers/std-out/index.ts
+var output = {
+  error: outputFactory("error"),
+  warn: outputFactory("warn"),
+  info: outputFactory("info")
+};
+
+export {
+  printTable,
+  output
+};

package/chunks/chunk-T7B6WNZC.js

@@ -0,0 +1,18 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+
+// src/domains/project/resolve-project.ts
+async function resolveProject(slug, apiClient) {
+  const githubResult = await apiClient.github.getProject(slug);
+  if (!githubResult.error) {
+    return { kind: "github", project: githubResult.data };
+  }
+  const docsResult = await apiClient.docsProject.getProject(slug);
+  if (!docsResult.error) {
+    return { kind: "docs", project: docsResult.data };
+  }
+  return { kind: "not-found" };
+}
+
+export {
+  resolveProject
+};