@scalar/cli 2.0.1 → 2.1.0

package/chunks/chunk-5BPPGTUU.js

@@ -0,0 +1,463 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  baseRegistrySchema
+} from "./chunk-VTYTPSXO.js";
+import {
+  brandedUid,
+  docVersionSchema,
+  entitySchema,
+  mintUid,
+  namespaceSchema,
+  nanoidSchema,
+  slugSchema,
+  timestampSchema
+} from "./chunk-ISGLWBXZ.js";
+import {
+  external_exports
+} from "./chunk-H2WRMLYY.js";
+import {
+  require_dist
+} from "./chunk-K74E42RV.js";
+import {
+  __toESM
+} from "./chunk-3MZYUBJ6.js";
+
+// ../../packages/entities/dist/sdk/schema.js
+var SdkLanguage;
+(function(SdkLanguage2) {
+  SdkLanguage2["Typescript"] = "typescript";
+  SdkLanguage2["Python"] = "python";
+  SdkLanguage2["Cli"] = "cli";
+  SdkLanguage2["CSharp"] = "csharp";
+  SdkLanguage2["Java"] = "java";
+  SdkLanguage2["Ruby"] = "ruby";
+  SdkLanguage2["Php"] = "php";
+  SdkLanguage2["Go"] = "go";
+  SdkLanguage2["Rust"] = "rust";
+  SdkLanguage2["Kotlin"] = "kotlin";
+  SdkLanguage2["Swift"] = "swift";
+  SdkLanguage2["Cpp"] = "cpp";
+  SdkLanguage2["Dart"] = "dart";
+})(SdkLanguage || (SdkLanguage = {}));
+var SdkLanguageLabels = {
+  [SdkLanguage.Typescript]: "Typescript",
+  [SdkLanguage.Python]: "Python",
+  [SdkLanguage.Cli]: "CLI",
+  [SdkLanguage.CSharp]: "C#",
+  [SdkLanguage.Java]: "Java",
+  [SdkLanguage.Ruby]: "Ruby",
+  [SdkLanguage.Php]: "PHP",
+  [SdkLanguage.Go]: "Go",
+  [SdkLanguage.Rust]: "Rust",
+  [SdkLanguage.Kotlin]: "Kotlin",
+  [SdkLanguage.Swift]: "Swift",
+  [SdkLanguage.Cpp]: "C++",
+  [SdkLanguage.Dart]: "Dart"
+};
+var SdkRegistryLabels = {
+  [SdkLanguage.Typescript]: "npm",
+  [SdkLanguage.Python]: "PyPI",
+  [SdkLanguage.Go]: "Go modules",
+  [SdkLanguage.Rust]: "crates.io",
+  [SdkLanguage.Java]: "Maven Central",
+  [SdkLanguage.Kotlin]: "Maven Central",
+  [SdkLanguage.Ruby]: "RubyGems",
+  [SdkLanguage.Php]: "Packagist",
+  [SdkLanguage.CSharp]: "NuGet",
+  [SdkLanguage.Swift]: "Swift Package Manager",
+  [SdkLanguage.Dart]: "pub.dev",
+  [SdkLanguage.Cli]: "Homebrew"
+};
+var SdkLanguageExperimental = {
+  [SdkLanguage.Typescript]: false,
+  [SdkLanguage.Python]: false,
+  [SdkLanguage.Cli]: false,
+  [SdkLanguage.CSharp]: true,
+  [SdkLanguage.Java]: true,
+  [SdkLanguage.Ruby]: true,
+  [SdkLanguage.Php]: true,
+  [SdkLanguage.Go]: false,
+  [SdkLanguage.Rust]: true,
+  [SdkLanguage.Kotlin]: true,
+  [SdkLanguage.Swift]: true,
+  [SdkLanguage.Cpp]: true,
+  [SdkLanguage.Dart]: true
+};
+var sdkTargetDestinationSchema = external_exports.object({
+  provider: external_exports.literal("github").default("github"),
+  linkedBy: external_exports.string(),
+  /**
+   * GitHub App installation that grants push access. Optional because legacy
+   * links predate it and it is derivable from `linkedBy` + repo at sync time.
+   */
+  installationId: external_exports.number().int().optional(),
+  /** GitHub repo id — the auth anchor and the webhook routing key. */
+  id: external_exports.number().int(),
+  expired: external_exports.boolean().default(false)
+}).meta({ id: "sdk-target-destination" });
+var sdkSampleRepoSchema = external_exports.object({
+  provider: external_exports.literal("github").default("github"),
+  /**
+   * 'pending' from SDK creation until the repo is provisioned in scalar-sdks;
+   * 'ready' once it exists (name/installationId are filled in then). The
+   * pending state lets the dashboard show the section immediately. Defaults to
+   * 'ready' so pre-existing bindings (which always have a repo) read correctly.
+   */
+  status: external_exports.enum(["pending", "ready"]).default("ready"),
+  /** "scalar-sdks/<repo>" (present once ready). */
+  name: external_exports.string().optional(),
+  /** scalar-sdks installation that grants push access for the bot (once ready). */
+  installationId: external_exports.number().int().optional(),
+  baseBranch: external_exports.string().min(1).default("main"),
+  /**
+   * GitHub invitation accept URL, surfaced in the dashboard. Null once the
+   * invite has been re-issued for an already-accepted user (no link to show).
+   */
+  invitationUrl: external_exports.string().nullable().optional(),
+  /**
+   * When provisioning was first kicked for this target (unix seconds), stamped
+   * as the pending binding is seeded. The dashboard anchors its stalled-timeout
+   * on it so a target added long after the SDK was created still gets the full
+   * "Preparing" window instead of reading as stalled immediately. Absent on
+   * pre-feature bindings (readers fall back to the SDK's `createdAt`).
+   */
+  provisionStartedAt: timestampSchema.optional(),
+  /** Last build whose artifact was pushed to the playground. */
+  lastSyncedBuild: nanoidSchema.optional()
+}).meta({ id: "sdk-sample-repo" });
+var sdkTargetSchema = external_exports.object({
+  language: external_exports.enum(SdkLanguage),
+  slug: slugSchema,
+  destination: sdkTargetDestinationSchema.nullable().default(null),
+  /**
+   * Preview repo in scalar-sdks for this target. Independent of `destination`:
+   * it always mirrors the latest build so users can play with the output before
+   * setting up a production repo.
+   */
+  sample: sdkSampleRepoSchema.nullable().default(null)
+}).meta({ id: "sdk-target" });
+var sdkVersionTargetStateSchema = external_exports.object({
+  activeSync: external_exports.object({
+    repository: external_exports.string(),
+    /**
+     * The release PR managed by release-please on scalar-next, when one
+     * was open after the sync. Release cutting is the repo's own workflow.
+     */
+    pullRequest: external_exports.number().optional(),
+    /** scalar-next tip the sync landed. */
+    commitHash: external_exports.string()
+  }).optional(),
+  /**
+   * Set when the last combine merge collided: the build awaiting resolution
+   * on the conflict PR (scalar-merge-conflict into scalar-next), resolved by
+   * the developer on GitHub. Cleared on a clean reconcile.
+   */
+  conflict: external_exports.object({
+    build: nanoidSchema,
+    /** The conflict PR into scalar-next, for deep links. */
+    pullRequest: external_exports.number().optional()
+  }).optional(),
+  activeBuild: nanoidSchema.optional()
+}).meta({ id: "sdk-version-target-state" });
+var sdkVersionStatusSchema = external_exports.enum(["draft", "published"]);
+var sdkVersionSchema = external_exports.object({
+  version: docVersionSchema,
+  /**
+   * The exact API version this SDK version was created against (build
+   * provenance). Always concrete — the SDK-level `sdkSchema.apiVersion` is
+   * the range-capable auto-update spec.
+   */
+  apiVersion: docVersionSchema,
+  createdAt: timestampSchema.optional(),
+  /** Draft while being edited; published once a build of it succeeds. */
+  status: sdkVersionStatusSchema.default("published"),
+  /** Config snapshot for this version. Defaults to `{}` so pre-migration docs still validate. */
+  config: external_exports.string().default("{}"),
+  /** Language targets this version ships, derived from `config`. */
+  languages: external_exports.enum(SdkLanguage).array().default([]),
+  publishedAt: timestampSchema.optional(),
+  /** What created/last-touched this version, for display. */
+  changeSource: external_exports.enum(["user", "api-version", "created"]).optional(),
+  changeNote: external_exports.string().optional(),
+  /**
+   * Content identity of the API document save that auto-created this
+   * version: the managed doc version's `jsonSha` — the same key space as
+   * {@link sdkBuildApiSchema}'s `documentHash`. Lets redelivered (or
+   * repeated, identical) save events recognize content the SDK already
+   * processed instead of minting another version.
+   */
+  apiDocumentHash: external_exports.string().optional(),
+  /** Active sync/build per language, for this version. */
+  targets: external_exports.partialRecord(external_exports.enum(SdkLanguage), sdkVersionTargetStateSchema).default({})
+}).meta({ id: "sdk-version" });
+var sdkSchema = baseRegistrySchema.extend({
+  /** Own uid, branded so it cannot be confused with another entity's uid */
+  uid: brandedUid().default(mintUid).meta({ default: "nanoid()" }),
+  /**
+   * The registry API this SDK is generated from. Null when unlinked — the SDK
+   * keeps its versions/builds but can't build a new version until re-linked.
+   *
+   * Branded as a ManagedDoc uid: this points at a managed DOC, not a managed
+   * SCHEMA, so comparing it to a `ManagedSchema` uid is a compile error.
+   */
+  apiUid: brandedUid().nullable(),
+  /**
+   * The API version this SDK follows — the auto-update gate. An exact value
+   * (`3.0.1`, kept in sync with the version the SDK is on) auto-rebuilds only
+   * when that version's content changes; a range prefix widens it (`~1.2.0`
+   * adds patch bumps, `^1.2.3` minors, `3` any 3.x, `*` any version). Ranges
+   * are user intent and never rewritten by the platform. Distinct from
+   * `sdkVersionSchema.apiVersion`, the exact build provenance of one SDK
+   * version. Null while unlinked; absent on pre-feature docs (readers fall
+   * back to the tracked version with exact semantics). `docVersionSchema`
+   * keeps the same floor as every other version field: non-empty, no
+   * reserved names (`latest` would be a spec that can never match).
+   */
+  apiVersion: docVersionSchema.nullable().optional(),
+  /**
+   * Current latest revision
+   * for SDK. Can be selected
+   * by user.
+   */
+  currentVersion: nanoidSchema,
+  /** All versions available for SDK. */
+  versions: sdkVersionSchema.array().default([]),
+  /**
+   * Persistent per-language registry: every language the SDK has, each with its
+   * registry slug + git destination. Survives across versions — destinations and
+   * slugs persist even when a version drops a language. The *active* language set
+   * is the latest published version's `languages`.
+   */
+  targets: sdkTargetSchema.array().min(1),
+  /**
+   * @deprecated Config now lives per-version (`sdkVersionSchema.config`). Kept
+   * optional for the migration/legacy path; new code reads the version config.
+   */
+  config: external_exports.string().optional()
+}).meta({ id: "sdk" });
+var sdkBuildStatusSchema = external_exports.enum(["pending", "error", "generated"]).meta({ id: "sdk-build-status" });
+var sdkGitStatusSchema = external_exports.enum(["pending", "error", "synced", "conflicts"]).meta({ id: "sdk-git-status" });
+var sdkBuildApiSchema = external_exports.object({
+  uid: nanoidSchema,
+  namespace: namespaceSchema,
+  version: docVersionSchema,
+  slug: slugSchema,
+  upgraded: external_exports.boolean().default(false),
+  /**
+   * Identity of the API document content this build was enqueued against:
+   * the managed doc version's `jsonSha` at enqueue time. Rebuild triggering
+   * compares it with the version's current `jsonSha` — an in-place content
+   * rewrite that lands between enqueue and generation makes the comparison
+   * conservatively re-trigger rather than miss the change. Nullable:
+   * document versions hashed before `jsonSha` existed carry none, and
+   * mongobase round-trips an unset optional as null.
+   */
+  documentHash: external_exports.string().nullable().optional()
+}).meta({ id: "sdk-build-api" });
+var sdkbuildSdkSchema = external_exports.object({
+  uid: nanoidSchema,
+  namespace: namespaceSchema,
+  version: docVersionSchema,
+  slug: slugSchema
+}).meta({ id: "sdk-build-sdk" });
+var sdkBuildGitSchema = external_exports.object({
+  /**
+   * The release PR (clean sync) or conflict PR (conflicted sync), when one
+   * exists. Nullable: mongobase round-trips an unset optional as null, and a
+   * strict number parse would drop the doc on read.
+   */
+  pullRequest: external_exports.number().nullable().optional(),
+  commitHash: external_exports.string()
+}).optional().meta({ id: "sdk-build-git" });
+var sdkBuildTargetSchema = external_exports.object({
+  /** SDK language to generate */
+  language: external_exports.enum(SdkLanguage),
+  /** Per-target published slug the artifact lands under */
+  slug: slugSchema,
+  /** Build status */
+  buildStatus: sdkBuildStatusSchema,
+  /**
+   * Additional build message. Nullable: mongobase round-trips an unset
+   * optional as null, and a strict string parse would drop the doc on read.
+   */
+  buildMessage: external_exports.string().nullable().optional(),
+  /** Git sync status */
+  gitStatus: sdkGitStatusSchema.optional(),
+  /**
+   * When the target entered `gitStatus: 'pending'`, in unix seconds. Lets a
+   * still-"pending" sync be recognized as stalled (a terminal message never
+   * arrived) so the dashboard can offer a retry instead of spinning forever.
+   * Nullable for the same round-trip reason as buildMessage.
+   */
+  syncStartedAt: external_exports.number().nullable().optional(),
+  /** Additional git message. Nullable for the same round-trip reason as buildMessage. */
+  gitMessage: external_exports.string().nullable().optional(),
+  /**
+   * Machine-readable git failure class assigned by the generator (e.g.
+   * 'github-workflows-permission'). Nullable for the same round-trip reason
+   * as buildMessage.
+   */
+  gitErrorCode: external_exports.string().nullable().optional(),
+  /** Linked git repository name */
+  repository: external_exports.string().nullable().optional(),
+  /** Git sync commit and PR */
+  gitSync: sdkBuildGitSchema
+}).meta({ id: "sdk-build-target" });
+var sdkBuildSchema = entitySchema.extend({
+  teamUid: nanoidSchema,
+  /** SDK metadata on generation */
+  sdk: sdkbuildSdkSchema,
+  /** Original API used to generate SDK */
+  api: sdkBuildApiSchema,
+  /** Custom SDK config */
+  config: external_exports.string(),
+  /** Should auto set active sdk version */
+  autoBump: external_exports.boolean().default(false),
+  /** Per-language build targets */
+  targets: sdkBuildTargetSchema.array().min(1)
+}).meta({ id: "sdk-build" });
+var sdkBuildLogChunkSchema = entitySchema.extend({
+  teamUid: nanoidSchema,
+  buildUid: nanoidSchema,
+  /** Monotonic order within a build. */
+  sequence: external_exports.number().int(),
+  chunk: external_exports.string()
+}).meta({ id: "sdk-build-log-chunk" });
+var sdkCodeSampleSchema = external_exports.object({
+  lang: external_exports.string(),
+  label: external_exports.string(),
+  source: external_exports.string()
+}).meta({ id: "sdk-code-sample" });
+
+// ../../packages/entities/dist/sdk/auto-update.js
+import semver2 from "semver";
+
+// ../../packages/entities/dist/sdk/helpers.js
+import semver from "semver";
+
+// ../../packages/entities/dist/sdk/scalar-config.js
+var import_yaml = __toESM(require_dist(), 1);
+var SCALAR_TARGET_LANGUAGES = [
+  "node",
+  "typescript",
+  "python",
+  "go",
+  "rust",
+  "java",
+  "kotlin",
+  "ruby",
+  "swift",
+  "terraform",
+  "cli",
+  "php",
+  "csharp",
+  "cpp",
+  "dart",
+  "sql",
+  "http",
+  "openapi"
+];
+var scalarTargetLanguageSchema = external_exports.enum(SCALAR_TARGET_LANGUAGES).meta({ id: "scalar-target-language" });
+var sdkLanguageToScalarTarget = {
+  [SdkLanguage.Typescript]: "typescript",
+  [SdkLanguage.Python]: "python",
+  [SdkLanguage.CSharp]: "csharp",
+  [SdkLanguage.Java]: "java",
+  [SdkLanguage.Ruby]: "ruby",
+  [SdkLanguage.Php]: "php",
+  [SdkLanguage.Go]: "go",
+  [SdkLanguage.Rust]: "rust",
+  [SdkLanguage.Kotlin]: "kotlin",
+  [SdkLanguage.Swift]: "swift",
+  [SdkLanguage.Cpp]: "cpp",
+  [SdkLanguage.Dart]: "dart",
+  [SdkLanguage.Cli]: "cli"
+};
+var sdkLanguageToRegistry = {
+  [SdkLanguage.Typescript]: "npm",
+  [SdkLanguage.Python]: "pypi",
+  [SdkLanguage.Go]: "go",
+  [SdkLanguage.Rust]: "cargo",
+  [SdkLanguage.Java]: "maven",
+  [SdkLanguage.Kotlin]: "maven",
+  [SdkLanguage.Ruby]: "rubygems",
+  [SdkLanguage.Php]: "packagist",
+  [SdkLanguage.CSharp]: "nuget",
+  [SdkLanguage.Swift]: "swiftpm",
+  [SdkLanguage.Dart]: "pub",
+  [SdkLanguage.Cli]: "homebrew"
+};
+var registryPackageUrls = {
+  [SdkLanguage.Typescript]: (name) => `https://www.npmjs.com/package/${name}`,
+  [SdkLanguage.Python]: (name) => `https://pypi.org/project/${name}`,
+  [SdkLanguage.Ruby]: (name) => `https://rubygems.org/gems/${name}`,
+  [SdkLanguage.Rust]: (name) => `https://crates.io/crates/${name}`,
+  [SdkLanguage.CSharp]: (name) => `https://www.nuget.org/packages/${name}`,
+  [SdkLanguage.Dart]: (name) => `https://pub.dev/packages/${name}`,
+  // Packagist pages exist only for `vendor/name` packages.
+  [SdkLanguage.Php]: (name) => name.includes("/") ? `https://packagist.org/packages/${name}` : null
+};
+var scalarTargetDestinationsSchema = external_exports.object({
+  production: external_exports.object({
+    repo: external_exports.string(),
+    branch: external_exports.string().optional()
+  }).optional()
+}).meta({ id: "scalar-target-destinations" });
+var scalarTargetEntrySchema = external_exports.looseObject({
+  packageName: external_exports.string().optional(),
+  // Prerelease channel for the target's releases (release-please's
+  // `prerelease-type` with its `prerelease` versioning strategy): releases
+  // version as `1.2.0-<type>.1`, `-<type>.2`, … auto-incrementing. Absent
+  // falls back to the channel the promote branch implies (see
+  // derivePrereleaseType); a conventional branch like `main` means stable
+  // releases.
+  prereleaseType: external_exports.string().optional(),
+  destinations: scalarTargetDestinationsSchema.optional(),
+  // Per-registry publish config (e.g. `{ npm: { authMethod: 'oidc' } }`). Present only when the
+  // target opts into publish-on-merge; the generator reads it to emit publish workflow steps.
+  publish: external_exports.record(external_exports.string(), external_exports.any()).optional()
+}).meta({ id: "scalar-target-entry" });
+var scalarClientSettingsSchema = external_exports.looseObject({
+  opts: external_exports.record(external_exports.string(), external_exports.any()).optional(),
+  defaultHeaders: external_exports.record(external_exports.string(), external_exports.string()).optional(),
+  defaultTimeout: external_exports.union([external_exports.number(), external_exports.string()]).optional(),
+  defaultEnvPrefix: external_exports.string().optional()
+}).meta({ id: "scalar-client-settings" });
+var scalarDiagnosticsSchema = external_exports.looseObject({
+  failOn: external_exports.enum(["off", "info", "warn", "error"]).optional(),
+  maxWarnings: external_exports.number().optional()
+}).meta({ id: "scalar-diagnostics" });
+var scalarSdkConfigSchema = external_exports.looseObject({
+  name: external_exports.string().optional(),
+  resources: external_exports.record(external_exports.string(), external_exports.any()).optional(),
+  targets: external_exports.partialRecord(scalarTargetLanguageSchema, scalarTargetEntrySchema).optional(),
+  clientSettings: scalarClientSettingsSchema.optional(),
+  environments: external_exports.record(external_exports.string(), external_exports.string()).optional(),
+  codeSampleLanguages: scalarTargetLanguageSchema.array().optional(),
+  diagnostics: scalarDiagnosticsSchema.optional()
+}).meta({ id: "scalar-sdk-config" });
+var scalarTargetToSdkLanguage = Object.fromEntries(Object.entries(sdkLanguageToScalarTarget).map(([language, target]) => [
+  target,
+  language
+]));
+var resolveSdkConfigRequestSchema = external_exports.object({
+  api: external_exports.object({
+    namespace: namespaceSchema,
+    slug: slugSchema,
+    version: docVersionSchema.optional(),
+    upgraded: external_exports.boolean().optional()
+  }),
+  namespace: namespaceSchema,
+  slug: slugSchema,
+  languages: external_exports.enum(SdkLanguage).array().min(1),
+  /** Candidate config to validate/complete; omit for the pure
+   * document-derived default. */
+  config: external_exports.string().optional()
+});
+
+export {
+  SdkLanguage,
+  sdkSchema,
+  sdkBuildSchema,
+  scalarSdkConfigSchema
+};

package/chunks/chunk-AEFPCC4U.js

@@ -0,0 +1,16 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+
+// ../../packages/helpers/dist/datetime/index.js
+function formatAbsoluteTime(date) {
+  return new Intl.DateTimeFormat("en", {
+    month: "short",
+    day: "numeric",
+    year: "numeric",
+    hour: "numeric",
+    minute: "2-digit"
+  }).format(new Date(date));
+}
+
+export {
+  formatAbsoluteTime
+};

package/chunks/chunk-AHWWJ3MD.js

@@ -0,0 +1,32 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+
+// src/domains/document/bundle/index.ts
+import { Command } from "commander";
+var DEFAULT_FETCH_CONCURRENCY = 5;
+function BundleCommand() {
+  const cmd = new Command("bundle");
+  cmd.description(
+    "Bundle an OpenAPI document by resolving all references and external dependencies"
+  );
+  cmd.argument("[file|url]", "Path to OpenAPI file or URL to bundle");
+  cmd.option("-o, --output <file>", "Path to save the bundled output file");
+  cmd.option("--treeShake", "Remove unused components from the bundled output");
+  cmd.option(
+    "--urlMap",
+    "Generate a map of resolved URLs in the bundled output"
+  );
+  cmd.option(
+    "--fetchLimit <limit>",
+    "Maximum number of URLs to fetch during bundling at the same time"
+  );
+  cmd.action(async (...args) => {
+    const { bundleAction } = await import("./action-BYZUBXVB.js");
+    return bundleAction(...args);
+  });
+  return cmd;
+}
+
+export {
+  DEFAULT_FETCH_CONCURRENCY,
+  BundleCommand
+};

package/chunks/chunk-ASMHW5AY.js

@@ -0,0 +1,19 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  userSchema
+} from "./chunk-B6QZJWCQ.js";
+
+// src/domains/team/helpers.ts
+var getUserTeams = async (client, email) => {
+  const user = await client.getOne({
+    collectionPath: "users",
+    query: { email },
+    schema: userSchema
+  });
+  if (user.error) return user;
+  return { error: false, data: user.data.teams };
+};
+
+export {
+  getUserTeams
+};

package/chunks/chunk-B6QZJWCQ.js

@@ -0,0 +1,92 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  teamImageSchema,
+  teamNameSchema
+} from "./chunk-4DGQIAJX.js";
+import {
+  brandedUid,
+  emailSchema,
+  entitySchema,
+  mintUid,
+  timestampSchema
+} from "./chunk-ISGLWBXZ.js";
+import {
+  external_exports,
+  zod_default
+} from "./chunk-H2WRMLYY.js";
+
+// ../../packages/entities/dist/user/bitbucket.js
+var userBitbucketSchema = entitySchema.extend({
+  token: zod_default.string(),
+  refreshToken: zod_default.string(),
+  expiry: timestampSchema,
+  refreshExpiry: timestampSchema
+}).meta({ id: "user-bitbucket" });
+
+// ../../packages/entities/dist/user/github.js
+var userGithubSchema = entitySchema.extend({
+  token: zod_default.string(),
+  refreshToken: zod_default.string(),
+  expiry: timestampSchema,
+  refreshExpiry: timestampSchema
+}).meta({ id: "user-github" });
+
+// ../../packages/entities/dist/user/password.js
+var userPasswordSchema = entitySchema.extend({
+  passwordHash: external_exports.string().nullable().default(null),
+  salt: external_exports.string().nullable().default(null),
+  password: external_exports.string().nullable().default(null),
+  passwordDeprecatedExp: external_exports.number().nullable().default(null)
+}).overwrite((d) => {
+  if (d.passwordHash) {
+    d.password = null;
+    d.salt = null;
+    d.passwordDeprecatedExp = null;
+  }
+  return d;
+}).meta({ id: "user-password" });
+var emailSignupOtpSchema = entitySchema.extend({
+  email: emailSchema,
+  otp: external_exports.string().min(6).max(6),
+  otpClientId: external_exports.string(),
+  exp: timestampSchema
+}).meta({ id: "email-signup-otp" });
+
+// ../../packages/entities/dist/user/signup-meta.js
+var signupMetaSchema = entitySchema.extend({
+  email: zod_default.string().optional(),
+  ip: zod_default.string().optional(),
+  region: zod_default.string().optional(),
+  city: zod_default.string().optional(),
+  location: zod_default.string().optional()
+}).meta({ id: "signup-meta" });
+
+// ../../packages/entities/dist/user/user.js
+var teamRefSchema = zod_default.object({
+  // Brand only — keeps the runtime `z.string()` validation while flowing the
+  // Team brand into Team-scoped accessors.
+  teamUid: zod_default.string().brand(),
+  teamName: teamNameSchema,
+  teamImageUri: teamImageSchema
+}).meta({ id: "team-ref" });
+var userSchema = entitySchema.extend({
+  /** Own uid, branded so it cannot be confused with another entity's uid */
+  uid: brandedUid().default(mintUid).meta({
+    default: "nanoid()"
+  }),
+  theme: zod_default.string().optional(),
+  /** Email or other unique token identifier for performant auth lookup */
+  userIndex: zod_default.string().overwrite((s) => s.toLowerCase()),
+  /** Federated auth provided must have a linked email */
+  email: emailSchema,
+  teams: teamRefSchema.array(),
+  activeTeamId: zod_default.string().brand().nullable(),
+  hasGithub: zod_default.boolean().optional().default(false),
+  hasBitbucket: zod_default.boolean().optional().default(false),
+  /** Forgejo personal access token for git operations */
+  forgejoToken: zod_default.string().optional()
+}).meta({ id: "user" });
+
+export {
+  userSchema
+};