busa-sdk 0.9.3

package/dist/index.js

@@ -0,0 +1,2086 @@
+import { createORPCClient } from '@orpc/client';
+import { OpenAPILink } from '@orpc/openapi-client/fetch';
+import { oc, eventIterator } from '@orpc/contract';
+import { z } from 'zod';
+
+// src/client.ts
+var AttachmentMetadataSchema = z.record(z.string(), z.unknown());
+z.object({
+  id: z.string(),
+  url: z.string(),
+  fileName: z.string(),
+  mimeType: z.string(),
+  size: z.number().int().nonnegative()
+});
+var RequestUploadUrlInputSchema = z.object({
+  fileName: z.string().min(1).max(255),
+  mimeType: z.string().min(1),
+  sizeBytes: z.number().int().positive(),
+  spaceId: z.string().optional(),
+  context: z.string().regex(/^[a-zA-Z0-9_/-]+$/).max(100).optional(),
+  /** Content fingerprint (e.g. "sha256:<hex>") for dedup; computed client-side. */
+  contentHash: z.string().max(80).optional()
+});
+var ConfirmUploadInputSchema = z.object({
+  storageKey: z.string().min(1),
+  fileName: z.string().min(1).max(255),
+  mimeType: z.string().min(1),
+  sizeBytes: z.number().int().positive(),
+  spaceId: z.string().optional(),
+  context: z.string().regex(/^[a-zA-Z0-9_/-]+$/).max(100).optional(),
+  metadata: AttachmentMetadataSchema.optional(),
+  /** Content fingerprint (e.g. "sha256:<hex>") persisted for dedup. */
+  contentHash: z.string().max(80).optional()
+});
+var RequestUploadUrlVOSchema = z.object({
+  uploadUrl: z.string(),
+  storageKey: z.string(),
+  publicUrl: z.string(),
+  expiresIn: z.number(),
+  /**
+   * True when an identical file (same contentHash, same scope) already exists.
+   * The client should SKIP the byte upload and the confirm step, and use
+   * `attachmentId`/`publicUrl` directly. `uploadUrl` is empty in this case.
+   */
+  duplicate: z.boolean().optional(),
+  /** Existing attachment id — present only when `duplicate` is true. */
+  attachmentId: z.string().optional(),
+  /** Host-specific logical asset id, when the app maps uploads into an Asset library. */
+  assetId: z.string().optional()
+});
+var ConfirmUploadVOSchema = z.object({
+  success: z.boolean(),
+  attachmentId: z.string(),
+  /** Host-specific logical asset id, when the app maps uploads into an Asset library. */
+  assetId: z.string().optional(),
+  storageKey: z.string(),
+  publicUrl: z.string()
+});
+var AssetVOSchema = z.object({
+  id: z.string(),
+  attachmentId: z.string(),
+  name: z.string(),
+  contentKind: z.enum(["text", "binary"]),
+  metadata: z.record(z.string(), z.unknown()).default({}),
+  fileName: z.string(),
+  mimeType: z.string(),
+  size: z.number().int().nonnegative(),
+  url: z.string(),
+  contentHash: z.string().nullable(),
+  /** How many places reference this asset (Base records + Doc bodies). */
+  usageCount: z.number().int().nonnegative(),
+  createdAt: z.string()
+});
+var AssetUsageVOSchema = z.object({
+  ownerType: z.enum(["drive", "skill", "base", "doc", "file_node"]),
+  nodeId: z.string(),
+  nodeName: z.string(),
+  nodeType: z.string(),
+  /** Node slug, so the UI can link to the owning Base/Doc (`/{type}/{slug}`). */
+  nodeSlug: z.string(),
+  /** Drive/Skill mounted path, or null when the usage is not path-based. */
+  path: z.string().nullable(),
+  /** Base record id, or null for whole-node usages (e.g. a Doc body). */
+  recordId: z.string().nullable(),
+  /** Attachment field slug, or null for whole-node usages. */
+  fieldSlug: z.string().nullable(),
+  /** Doc block id, or null when the usage is not block-based. */
+  blockId: z.string().nullable(),
+  createdAt: z.string()
+});
+var AssetDetailVOSchema = z.object({
+  asset: AssetVOSchema,
+  usages: z.array(AssetUsageVOSchema)
+});
+
+// ../../packages/busabase-contract/src/domains/assets/contract.ts
+var UpdateAssetMetadataInputSchema = z.object({
+  assetId: z.string(),
+  metadata: z.record(z.string(), z.unknown()),
+  mode: z.enum(["merge", "replace"]).optional().default("merge")
+});
+var assetsContract = {
+  createUploadUrl: oc.route({
+    method: "POST",
+    path: "/assets/upload-urls",
+    tags: ["Assets"],
+    summary: "Request asset upload URL",
+    successDescription: "Presigned (or dev) upload URL plus the public URL and asset id when identical bytes are already in the library."
+  }).input(RequestUploadUrlInputSchema).output(RequestUploadUrlVOSchema),
+  confirm: oc.route({
+    method: "POST",
+    path: "/assets/confirmations",
+    tags: ["Assets"],
+    summary: "Confirm asset upload",
+    successDescription: "Recorded the file and ensured its Busabase Asset library entry."
+  }).input(ConfirmUploadInputSchema).output(ConfirmUploadVOSchema),
+  list: oc.route({
+    method: "GET",
+    path: "/assets",
+    tags: ["Assets"],
+    summary: "List assets",
+    successDescription: "Every asset in the space, with file metadata and usage counts."
+  }).output(z.array(AssetVOSchema)),
+  get: oc.route({
+    method: "GET",
+    path: "/assets/{assetId}",
+    tags: ["Assets"],
+    summary: "Get asset detail",
+    successDescription: "Asset metadata plus every place it is referenced (where-used)."
+  }).input(z.object({ assetId: z.string() })).output(AssetDetailVOSchema),
+  updateMetadata: oc.route({
+    method: "PATCH",
+    path: "/assets/{assetId}/metadata",
+    tags: ["Assets"],
+    summary: "Update asset metadata",
+    successDescription: "Updated AI-readable metadata for a file, such as summary, extracted text, tags, source URL, or schema-specific hints."
+  }).input(UpdateAssetMetadataInputSchema).output(AssetDetailVOSchema),
+  delete: oc.route({
+    method: "DELETE",
+    path: "/assets/{assetId}",
+    tags: ["Assets"],
+    summary: "Delete asset",
+    successDescription: "Removed the asset and, if no other row references its bytes, the stored object. Refused while the asset is still referenced (where-used)."
+  }).input(z.object({ assetId: z.string() })).output(z.object({ deleted: z.boolean() }))
+};
+var i18n = {
+  locales: ["en", "zh-CN", "zh-TW", "ja", "ko", "de", "fr", "es", "pt"]};
+var LocaleSchema = z.enum(i18n.locales);
+
+// ../../packages/openlib/i18n/i-string.ts
+var iStringRecordSchema = z.partialRecord(LocaleSchema, z.string());
+z.union([z.string(), iStringRecordSchema]).describe("i18n string");
+var fieldNameSchema = z.union([
+  z.string().min(1),
+  iStringRecordSchema.refine(
+    (record) => Object.values(record).some((value) => value && value.trim().length > 0),
+    "field name must have at least one non-empty locale value"
+  )
+]);
+var fieldTypeSchema = z.enum([
+  "text",
+  "longtext",
+  "markdown",
+  "html",
+  "attachment",
+  "relation",
+  "number",
+  "date",
+  "checkbox",
+  "select",
+  "multiselect",
+  "url",
+  "embed",
+  "email",
+  "phone",
+  "created_time",
+  "updated_time",
+  "created_by",
+  "updated_by",
+  "auto_number",
+  "ai_summary",
+  "ai_tags",
+  "code",
+  "json",
+  "yaml"
+]);
+var fieldOptionsSchema = z.object({
+  ai: z.object({
+    model: z.string().optional(),
+    prompt: z.string().optional(),
+    reviewRequired: z.boolean().optional(),
+    sourceFieldIds: z.array(z.string()).optional()
+  }).optional(),
+  // Per-field config for `attachment` columns (all optional; logic enforces a
+  // 25MB ceiling regardless).
+  attachment: z.object({
+    maxFiles: z.number().int().positive().optional(),
+    allowedMimeTypes: z.array(z.string()).optional(),
+    maxFileSize: z.number().int().positive().optional()
+  }).optional(),
+  choices: z.array(
+    z.object({
+      color: z.string().optional(),
+      id: z.string(),
+      name: z.string()
+    })
+  ).optional(),
+  code: z.object({
+    language: z.string().optional()
+  }).optional(),
+  embed: z.object({
+    aspectRatio: z.enum(["16:9", "4:3", "1:1"]).optional(),
+    height: z.number().int().positive().max(1200).optional(),
+    providers: z.array(z.string()).optional()
+  }).optional(),
+  inverseFieldId: z.string().optional(),
+  multiple: z.boolean().optional(),
+  // Display formatting for `number` columns (Notion-style: one number type,
+  // a format option). `currency` renders via Intl.NumberFormat.
+  number: z.object({
+    format: z.enum(["plain", "currency"]).optional(),
+    currency: z.string().optional(),
+    locale: z.string().optional()
+  }).optional(),
+  targetBaseId: z.string().optional().describe("Relation target Base id (bse_\u2026). Or pass targetBaseSlug to name it by slug."),
+  targetBaseSlug: z.string().optional().describe(
+    "Relation target Base by slug \u2014 a convenience alias for targetBaseId, resolved server-side (active bases in the current space). If both are given, targetBaseId wins."
+  )
+}).default({});
+var baseFieldSchema = z.object({
+  id: z.string(),
+  baseId: z.string(),
+  slug: z.string(),
+  name: fieldNameSchema,
+  type: fieldTypeSchema,
+  required: z.boolean(),
+  position: z.number(),
+  options: fieldOptionsSchema
+});
+var baseSchema = z.object({
+  id: z.string(),
+  nodeId: z.string(),
+  slug: z.string(),
+  name: z.string(),
+  description: z.string(),
+  reviewPolicy: z.object({
+    kind: z.literal("single"),
+    requiredApprovals: z.number()
+  }),
+  createdAt: z.string(),
+  fields: z.array(baseFieldSchema)
+});
+var createBaseInputSchema = z.object({
+  parentNodeId: z.string().optional(),
+  slug: z.string().min(1).regex(/^[a-z0-9-]+$/),
+  name: z.string().min(1),
+  description: z.string().optional().default(""),
+  fields: z.array(
+    z.object({
+      slug: z.string().min(1),
+      name: fieldNameSchema,
+      type: fieldTypeSchema.default("text"),
+      required: z.boolean().default(false),
+      options: fieldOptionsSchema.optional().default({})
+    })
+  ).default([])
+});
+var createBaseFieldInputSchema = z.object({
+  name: fieldNameSchema,
+  // Field slugs are snake_case identifiers (e.g. `cover_image`, `publish_date`) — the
+  // seed and the inline-fields path on `POST /bases` already allow underscores, so the
+  // add-field endpoint must too. (Base/folder/view slugs stay kebab-case: they go in URLs.)
+  slug: z.string().min(1).regex(/^[a-z0-9_-]+$/),
+  type: fieldTypeSchema.default("text"),
+  required: z.boolean().optional().default(false),
+  options: fieldOptionsSchema.optional().default({})
+});
+var createFieldChangeRequestInputSchema = createBaseFieldInputSchema.extend({
+  message: z.string().optional().default("Add field"),
+  submittedBy: z.string().optional().default("local-editor")
+});
+var deleteFieldChangeRequestInputSchema = z.object({
+  fieldId: z.string().min(1),
+  message: z.string().optional(),
+  submittedBy: z.string().optional().default("local-editor")
+});
+var updateFieldChangeRequestInputSchema = z.object({
+  fieldId: z.string().min(1),
+  patch: z.object({
+    name: fieldNameSchema.optional(),
+    required: z.boolean().optional(),
+    options: fieldOptionsSchema.optional()
+  }),
+  message: z.string().optional(),
+  submittedBy: z.string().optional().default("local-editor")
+});
+var previewFieldConversionInputSchema = z.object({
+  fieldId: z.string().min(1),
+  newType: fieldTypeSchema
+});
+var previewFieldConversionOutputSchema = z.object({
+  totalCount: z.number(),
+  convertibleCount: z.number(),
+  nullCount: z.number(),
+  conflicts: z.array(z.object({ recordId: z.string(), currentValue: z.unknown() }))
+});
+var convertFieldChangeRequestInputSchema = z.object({
+  fieldId: z.string().min(1),
+  newType: fieldTypeSchema,
+  selectChoiceMode: z.enum(["auto_create", "null_on_missing"]).default("null_on_missing"),
+  message: z.string().optional(),
+  submittedBy: z.string().optional().default("local-editor")
+});
+var reorderFieldsChangeRequestInputSchema = z.object({
+  fieldIds: z.array(z.string()).min(1),
+  message: z.string().optional(),
+  submittedBy: z.string().optional().default("local-editor")
+});
+var archiveBaseInputSchema = z.object({
+  message: z.string().optional(),
+  submittedBy: z.string().optional().default("local-editor")
+});
+var restoreBaseInputSchema = z.object({
+  message: z.string().optional(),
+  submittedBy: z.string().optional().default("local-editor")
+});
+var restoreFieldChangeRequestInputSchema = z.object({
+  fieldId: z.string().min(1),
+  message: z.string().optional(),
+  submittedBy: z.string().optional().default("local-editor")
+});
+
+// ../../packages/busabase-contract/src/domains/base/definition.ts
+var baseNodeType = {
+  type: "base",
+  label: "Base",
+  icon: "table",
+  capabilities: { hasDetail: true, creatable: true },
+  operations: [
+    {
+      kind: "record_create",
+      label: "Create",
+      tone: "border-emerald-200 bg-emerald-50 text-emerald-800"
+    },
+    { kind: "record_update", label: "Update", tone: "border-sky-200 bg-sky-50 text-sky-800" },
+    { kind: "record_delete", label: "Delete", tone: "border-red-200 bg-red-50 text-red-800" },
+    {
+      kind: "record_variant",
+      label: "Variant",
+      tone: "border-violet-200 bg-violet-50 text-violet-800"
+    },
+    {
+      kind: "view_create",
+      label: "Create view",
+      tone: "border-indigo-200 bg-indigo-50 text-indigo-800"
+    },
+    { kind: "view_update", label: "Update view", tone: "border-blue-200 bg-blue-50 text-blue-800" },
+    { kind: "view_delete", label: "Delete view", tone: "border-rose-200 bg-rose-50 text-rose-800" },
+    {
+      kind: "view_restore",
+      label: "Restore view",
+      tone: "border-emerald-200 bg-emerald-50 text-emerald-800"
+    },
+    {
+      kind: "base_add_field",
+      label: "Add field",
+      tone: "border-emerald-200 bg-emerald-50 text-emerald-800"
+    },
+    {
+      kind: "base_delete_field",
+      label: "Delete field",
+      tone: "border-red-200 bg-red-50 text-red-800"
+    },
+    {
+      kind: "base_update_field",
+      label: "Update field",
+      tone: "border-sky-200 bg-sky-50 text-sky-800"
+    },
+    {
+      kind: "base_convert_field",
+      label: "Convert field",
+      tone: "border-violet-200 bg-violet-50 text-violet-800"
+    },
+    {
+      kind: "base_reorder_fields",
+      label: "Reorder fields",
+      tone: "border-indigo-200 bg-indigo-50 text-indigo-800"
+    },
+    {
+      kind: "base_restore_field",
+      label: "Restore field",
+      tone: "border-teal-200 bg-teal-50 text-teal-800"
+    },
+    {
+      kind: "base_archive",
+      label: "Archive base",
+      tone: "border-orange-200 bg-orange-50 text-orange-800"
+    },
+    {
+      kind: "base_restore",
+      label: "Restore base",
+      tone: "border-teal-200 bg-teal-50 text-teal-800"
+    },
+    {
+      kind: "record_restore",
+      label: "Restore record",
+      tone: "border-teal-200 bg-teal-50 text-teal-800"
+    }
+  ]
+};
+
+// ../../packages/busabase-contract/src/domains/doc/definition.ts
+var docNodeType = {
+  type: "doc",
+  label: "Doc",
+  icon: "file-text",
+  capabilities: { hasDetail: true, creatable: true },
+  operations: [
+    {
+      kind: "doc_update",
+      label: "Update doc",
+      tone: "border-blue-200 bg-blue-50 text-blue-800"
+    }
+  ]
+};
+
+// ../../packages/busabase-contract/src/domains/filetree/definition.ts
+var fileTreeOperations = (type) => [
+  {
+    kind: `${type}_file_create`,
+    label: "Create file",
+    tone: "border-emerald-200 bg-emerald-50 text-emerald-800"
+  },
+  {
+    kind: `${type}_file_update`,
+    label: "Update file",
+    tone: "border-blue-200 bg-blue-50 text-blue-800"
+  },
+  {
+    kind: `${type}_file_delete`,
+    label: "Delete file",
+    tone: "border-rose-200 bg-rose-50 text-rose-800"
+  },
+  {
+    kind: `${type}_metadata_update`,
+    label: `Update ${type}`,
+    tone: "border-violet-200 bg-violet-50 text-violet-800"
+  }
+];
+var makeFileTreeNodeType = (config) => ({
+  type: config.type,
+  label: config.label,
+  icon: config.icon,
+  capabilities: { hasDetail: true, creatable: true },
+  operations: fileTreeOperations(config.type)
+});
+
+// ../../packages/busabase-contract/src/domains/drive/definition.ts
+var driveNodeType = makeFileTreeNodeType({
+  type: "drive",
+  label: "Drive",
+  icon: "hard-drive"});
+
+// ../../packages/busabase-contract/src/domains/file-node/definition.ts
+var fileNodeType = {
+  type: "file",
+  label: "File",
+  icon: "file",
+  capabilities: { hasDetail: true, creatable: true },
+  operations: []
+};
+
+// ../../packages/busabase-contract/src/domains/folder/definition.ts
+var folderNodeType = {
+  type: "folder",
+  label: "Folder",
+  icon: "folder",
+  capabilities: { container: true, creatable: true, hasDetail: true },
+  operations: []
+};
+
+// ../../packages/busabase-contract/src/domains/skill/definition.ts
+var skillNodeType = makeFileTreeNodeType({
+  type: "skill",
+  label: "Skill",
+  icon: "sparkles"});
+
+// ../../packages/busabase-contract/src/domains/registry.ts
+var GENERIC_NODE_OPERATIONS = [
+  {
+    kind: "node_create",
+    label: "Create node",
+    tone: "border-emerald-200 bg-emerald-50 text-emerald-800"
+  },
+  { kind: "node_rename", label: "Rename node", tone: "border-sky-200 bg-sky-50 text-sky-800" },
+  { kind: "node_delete", label: "Delete node", tone: "border-red-200 bg-red-50 text-red-800" },
+  {
+    kind: "node_restore",
+    label: "Restore node",
+    tone: "border-emerald-200 bg-emerald-50 text-emerald-800"
+  },
+  { kind: "node_move", label: "Move node", tone: "border-indigo-200 bg-indigo-50 text-indigo-800" }
+];
+var registry = /* @__PURE__ */ new Map();
+function registerNodeType(definition) {
+  registry.set(definition.type, definition);
+}
+var BUILTIN_NODE_TYPES = [
+  folderNodeType,
+  baseNodeType,
+  skillNodeType,
+  driveNodeType,
+  fileNodeType,
+  docNodeType
+];
+for (const definition of BUILTIN_NODE_TYPES) {
+  registerNodeType(definition);
+}
+var NODE_TYPES = BUILTIN_NODE_TYPES.map((definition) => definition.type);
+var CREATABLE_NODE_TYPES = BUILTIN_NODE_TYPES.filter(
+  (definition) => Boolean(definition.capabilities.creatable)
+).map((definition) => definition.type);
+var ALL_OPERATIONS = [
+  ...GENERIC_NODE_OPERATIONS,
+  ...BUILTIN_NODE_TYPES.flatMap(
+    (definition) => definition.operations
+  )
+];
+var OPERATION_KINDS = ALL_OPERATIONS.map((operation) => operation.kind);
+GENERIC_NODE_OPERATIONS.map(
+  (operation) => operation.kind
+);
+Object.fromEntries(
+  ALL_OPERATIONS.map((operation) => [
+    operation.kind,
+    { label: operation.label, tone: operation.tone }
+  ])
+);
+
+// ../../packages/busabase-contract/src/contract/schemas.ts
+var nodeSchema = z.lazy(
+  () => z.object({
+    id: z.string(),
+    parentId: z.string().nullable(),
+    type: z.enum(NODE_TYPES),
+    slug: z.string(),
+    name: z.string(),
+    description: z.string(),
+    metadata: z.object({
+      entryFile: z.string().optional(),
+      visibility: z.enum(["private", "workspace", "public"]).optional(),
+      version: z.string().optional(),
+      assetId: z.string().optional()
+    }).default({}),
+    position: z.number(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    baseId: z.string().nullable(),
+    children: z.array(nodeSchema)
+  })
+);
+var userRefSchema = z.object({
+  id: z.string(),
+  name: z.string().nullable(),
+  email: z.string().nullable(),
+  image: z.string().nullable(),
+  role: z.string().nullable().optional()
+});
+var commitSchema = z.object({
+  id: z.string(),
+  baseId: z.string().nullable(),
+  targetType: z.enum(["base", "node"]),
+  nodeId: z.string().nullable(),
+  operationId: z.string().nullable(),
+  parentCommitId: z.string().nullable(),
+  fields: z.record(z.string(), z.unknown()),
+  operation: z.enum(OPERATION_KINDS),
+  message: z.string(),
+  author: z.string(),
+  authorUser: userRefSchema.nullable().optional().default(null),
+  createdAt: z.string()
+});
+var operationSchema = z.object({
+  id: z.string(),
+  changeRequestId: z.string(),
+  baseId: z.string().nullable(),
+  targetType: z.enum(["base", "node"]),
+  nodeId: z.string().nullable(),
+  operation: z.enum(OPERATION_KINDS),
+  status: z.enum(["pending", "merged", "archived", "failed"]),
+  targetRecordId: z.string().nullable(),
+  targetViewId: z.string().nullable(),
+  filePath: z.string().nullable(),
+  sourceRecordId: z.string().nullable(),
+  sourceCommitId: z.string().nullable(),
+  baseCommitId: z.string().nullable(),
+  headCommitId: z.string(),
+  deleteMode: z.enum(["archive"]),
+  mergedRecordId: z.string().nullable(),
+  mergedViewId: z.string().nullable(),
+  position: z.number(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  headCommit: commitSchema,
+  // Resolved canonical "before" values for the operation's target, so the UI can
+  // render a true before → after field diff. Null for creations (no prior state)
+  // and for kinds whose prior state isn't a field map (e.g. skill files, whose
+  // previous content lives in storage). Records resolve from the base commit;
+  // views resolve from the current view row ({ name, description, config }).
+  baseFields: z.record(z.string(), z.unknown()).nullable()
+});
+var reviewSchema = z.object({
+  id: z.string(),
+  changeRequestId: z.string(),
+  reviewerId: z.string(),
+  reviewer: userRefSchema.nullable().optional().default(null),
+  verdict: z.enum(["approved", "rejected"]),
+  reason: z.string().nullable(),
+  visibleOperationHeads: z.record(z.string(), z.string()),
+  createdAt: z.string()
+});
+var commentSubjectTypeSchema = z.enum(["record", "change_request", "operation", "commit"]);
+var commentSchema = z.object({
+  id: z.string(),
+  subjectType: commentSubjectTypeSchema,
+  subjectId: z.string(),
+  recordId: z.string().nullable(),
+  changeRequestId: z.string().nullable(),
+  operationId: z.string().nullable(),
+  commitId: z.string().nullable(),
+  authorId: z.string(),
+  author: userRefSchema.nullable().optional().default(null),
+  body: z.string(),
+  mentionsAi: z.boolean(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+var changeRequestStatusSchema = z.enum([
+  "in_review",
+  "changes_requested",
+  "approved",
+  "rejected",
+  "merged",
+  "abandoned",
+  "conflict"
+]);
+var changeRequestSchema = z.object({
+  id: z.string(),
+  baseId: z.string().nullable(),
+  targetType: z.enum(["base", "node"]),
+  nodeId: z.string().nullable(),
+  status: changeRequestStatusSchema,
+  submittedBy: z.string(),
+  submittedByUser: userRefSchema.nullable().optional().default(null),
+  sourceMeta: z.record(z.string(), z.unknown()),
+  reviewPolicySnapshot: z.record(z.string(), z.unknown()),
+  mergeSummary: z.record(z.string(), z.unknown()),
+  rejectedReason: z.string().nullable(),
+  reviewedAt: z.string().nullable(),
+  mergedAt: z.string().nullable(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  base: baseSchema.nullable(),
+  node: nodeSchema.nullable(),
+  operations: z.array(operationSchema),
+  primaryOperation: operationSchema.nullable(),
+  operationCount: z.number(),
+  reviews: z.array(reviewSchema)
+});
+var agentTaskSchema = z.object({
+  changeRequest: changeRequestSchema,
+  trigger: z.enum(["changes_requested", "ai_mention"]),
+  reviewReason: z.string().nullable(),
+  aiComments: z.array(commentSchema)
+});
+var searchResultSchema = z.object({
+  id: z.string(),
+  kind: z.enum(["record", "change_request", "base", "file"]),
+  title: z.string(),
+  body: z.string(),
+  eyebrow: z.string(),
+  href: z.string(),
+  updatedAt: z.string().nullable()
+});
+var searchResponseSchema = z.object({
+  query: z.string(),
+  limit: z.number(),
+  offset: z.number(),
+  hasMore: z.boolean(),
+  results: z.array(searchResultSchema)
+});
+var liveEventSchema = z.object({
+  kind: z.enum([
+    "change_request.created",
+    "change_request.updated",
+    "change_request.deleted",
+    "change_request.reviewed",
+    "change_request.merged"
+  ]),
+  spaceId: z.string(),
+  actorId: z.string(),
+  changeRequestId: z.string(),
+  baseId: z.string().nullable(),
+  nodeIds: z.array(z.string()),
+  recordIds: z.array(z.string()),
+  viewIds: z.array(z.string()),
+  operationCount: z.number()
+});
+var auditActionSchema = z.enum([
+  "record.viewed",
+  "change_request.created",
+  "change_request.updated",
+  "change_request.deleted",
+  "change_request.reviewed",
+  "change_request.merged",
+  // Direct (non-change-request) mutations — recorded so the audit trail stays
+  // complete even for operations that bypass the propose → review → merge flow
+  // (container bootstrap, direct edits, library/asset deletes, trash purge).
+  "base.created",
+  "field.created",
+  "doc.created",
+  "doc.updated",
+  "file.created",
+  "skill.created",
+  "drive.created",
+  "asset.deleted",
+  "asset.metadata_updated",
+  "node.purged"
+]);
+var auditEventSchema = z.object({
+  id: z.string(),
+  action: auditActionSchema,
+  actorId: z.string(),
+  actor: userRefSchema.nullable().optional().default(null),
+  baseId: z.string().nullable(),
+  recordId: z.string().nullable(),
+  changeRequestId: z.string().nullable(),
+  operationId: z.string().nullable(),
+  commitId: z.string().nullable(),
+  metadata: z.record(z.string(), z.unknown()),
+  createdAt: z.string()
+});
+var createAuditEventInputSchema = z.object({
+  action: auditActionSchema,
+  actorId: z.string().optional().default("local-viewer"),
+  baseId: z.string().optional().nullable(),
+  recordId: z.string().optional().nullable(),
+  changeRequestId: z.string().optional().nullable(),
+  operationId: z.string().optional().nullable(),
+  commitId: z.string().optional().nullable(),
+  metadata: z.record(z.string(), z.unknown()).optional().default({})
+});
+var nodeOperationInputSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("create"),
+    ref: z.string().min(1).optional().describe(
+      'Optional in-change-request temp id for this node. A later operation can set parentNodeRef to this value to nest under it \u2014 e.g. create a folder with ref "growth", then create Bases with parentNodeRef "growth", all in one change request.'
+    ),
+    parentNodeId: z.string().optional(),
+    parentNodeRef: z.string().min(1).optional().describe(
+      "Parent this node under a node an EARLIER operation in the same change request created (matched by its ref). Mutually exclusive with parentNodeId."
+    ),
+    nodeType: z.enum(CREATABLE_NODE_TYPES),
+    slug: z.string().min(1).regex(/^[a-z0-9-]+$/),
+    name: z.string().min(1),
+    description: z.string().optional().default(""),
+    metadata: z.record(z.string(), z.unknown()).optional().default({}),
+    // Base fields (nodeType "base" only); a base needs at least one field.
+    fields: z.array(
+      z.object({
+        slug: z.string().min(1).regex(/^[a-z0-9-]+$/),
+        name: fieldNameSchema,
+        type: fieldTypeSchema.default("text"),
+        required: z.boolean().optional().default(false),
+        options: fieldOptionsSchema.optional().default({})
+      })
+    ).optional()
+  }),
+  z.object({
+    kind: z.literal("rename"),
+    nodeId: z.string(),
+    slug: z.string().min(1).regex(/^[a-z0-9-]+$/).optional(),
+    name: z.string().min(1).optional(),
+    description: z.string().optional()
+  }),
+  z.object({
+    kind: z.literal("delete"),
+    nodeId: z.string()
+  }),
+  z.object({
+    kind: z.literal("restore"),
+    nodeId: z.string()
+  }),
+  z.object({
+    kind: z.literal("move"),
+    nodeId: z.string(),
+    // Exactly one of parentNodeId / parentNodeRef (a ref created earlier in this CR).
+    parentNodeId: z.string().optional(),
+    parentNodeRef: z.string().min(1).optional(),
+    position: z.number().int().optional()
+  })
+]);
+var createNodeChangeRequestInputSchema = z.object({
+  message: z.string().optional().default("Update node tree").describe(
+    'Explanation shown to the human reviewer. Write a conventional-commit style subject \u2014 imperative verb + what + why, e.g. "Reorganize marketing docs under a Campaigns folder".'
+  ),
+  submittedBy: z.string().optional().default("local-producer"),
+  autoMerge: z.boolean().optional().default(false).describe(
+    "Whether to approve and merge this structural node change immediately. Defaults to false so node Change Request creation is review-first unless explicitly requested."
+  ),
+  operations: z.array(nodeOperationInputSchema).min(1)
+});
+var createDeleteChangeRequestInputSchema = z.object({
+  message: z.string().optional().default("Delete record").describe(
+    'Explanation shown to the human reviewer. Say what is being removed and why, e.g. "Archive duplicate contact \u2014 merged into Acme Corp".'
+  ),
+  submittedBy: z.string().optional().default("local-producer"),
+  // Only "archive" is supported — hard delete after retention was never
+  // implemented, so the API no longer accepts it (breaking change).
+  deleteMode: z.enum(["archive"]).optional().default("archive")
+});
+var reviseOperationInputSchema = z.object({
+  fields: z.record(z.string(), z.unknown()).describe(
+    "Updated field values keyed by field slug. If you set the base's PRIMARY field (its first field), keep it a short human-readable name \u2014 it is the record's display title everywhere."
+  ),
+  message: z.string().optional().default("Revise operation").describe(
+    'Explanation shown to the human reviewer. Write a conventional-commit style subject \u2014 imperative verb + what + why, e.g. "Update deal stage to qualified \u2014 demo booked for July 8".'
+  ),
+  author: z.string().optional().default("local-producer"),
+  baseCommitId: z.string().optional()
+});
+var reviewChangeRequestInputSchema = z.object({
+  verdict: z.enum(["approved", "rejected"]),
+  reason: z.string().optional()
+});
+var commentSubjectInputSchema = z.object({
+  subjectType: commentSubjectTypeSchema,
+  subjectId: z.string().min(1)
+});
+var createCommentInputSchema = commentSubjectInputSchema.extend({
+  authorId: z.string().optional().default("local-admin"),
+  body: z.string().trim().min(1),
+  mentionsAi: z.boolean().optional().default(false)
+});
+var listInputSchema = z.object({
+  limit: z.coerce.number().int().min(1).max(100).optional().default(50)
+}).optional().default({ limit: 50 });
+var listChangeRequestsPagedInputSchema = z.object({
+  limit: z.coerce.number().int().min(1).max(100).optional().default(50),
+  /** Opaque base64 cursor (`createdAt|id`) for keyset pagination. */
+  cursor: z.string().optional(),
+  status: z.array(changeRequestStatusSchema).optional(),
+  mine: z.boolean().optional()
+}).optional().default({ limit: 50 });
+var listChangeRequestsResponseSchema = z.object({
+  changeRequests: z.array(changeRequestSchema),
+  nextCursor: z.string().nullable()
+});
+var changeRequestCountsSchema = z.object({
+  review: z.number().int().nonnegative(),
+  changes: z.number().int().nonnegative(),
+  created: z.number().int().nonnegative(),
+  approved: z.number().int().nonnegative(),
+  merged: z.number().int().nonnegative(),
+  rejected: z.number().int().nonnegative()
+});
+var searchInputSchema = z.object({
+  query: z.string().default(""),
+  limit: z.coerce.number().int().min(1).max(100).optional().default(20),
+  offset: z.coerce.number().int().min(0).optional().default(0)
+});
+var authSpaceSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  slug: z.string().nullable(),
+  plan: z.string().nullable()
+});
+var authUserSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  email: z.string().nullable(),
+  image: z.string().nullable()
+});
+var authMemberSchema = z.object({
+  userId: z.string(),
+  spaceId: z.string(),
+  role: z.string()
+});
+var authInfoSchema = z.object({
+  /** The space this request is scoped to (explicit `x-busabase-space` header, else the default). */
+  space: authSpaceSchema,
+  user: authUserSchema,
+  member: authMemberSchema,
+  /**
+   * Every space the authenticated user belongs to. An API key is user-scoped, not
+   * space-scoped — when this has more than one entry, callers should confirm the
+   * intended space and target it explicitly via the `x-busabase-space` header.
+   */
+  spaces: z.array(authSpaceSchema)
+});
+var viewFilterOperatorSchema = z.enum([
+  "contains",
+  "equals",
+  "not_empty",
+  "is_empty",
+  "is_true",
+  "is_false"
+]);
+var viewFilterSchema = z.object({
+  fieldSlug: z.string(),
+  // Stable field identity — survives slug reuse; populated on merge.
+  fieldId: z.string().optional(),
+  operator: viewFilterOperatorSchema,
+  value: z.unknown().optional()
+});
+var viewSortSchema = z.object({
+  direction: z.enum(["asc", "desc"]),
+  fieldSlug: z.string(),
+  fieldId: z.string().optional()
+});
+var viewConfigSchema = z.object({
+  filters: z.array(viewFilterSchema).default([]),
+  sorts: z.array(viewSortSchema).default([]),
+  visibleFieldSlugs: z.array(z.string()).nullable().optional()
+});
+var viewSchema = z.object({
+  id: z.string(),
+  baseId: z.string(),
+  slug: z.string(),
+  name: z.string(),
+  description: z.string(),
+  type: z.literal("table"),
+  config: viewConfigSchema,
+  status: z.enum(["active", "archived"]),
+  createdBy: z.string(),
+  createdByUser: userRefSchema.nullable().optional().default(null),
+  archivedAt: z.string().nullable(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+var createViewInputSchema = z.object({
+  config: viewConfigSchema.optional().default({ filters: [], sorts: [] }),
+  description: z.string().optional().default(""),
+  message: z.string().optional().default("Create view"),
+  name: z.string().min(1),
+  slug: z.string().min(1).regex(/^[a-z0-9-]+$/).optional(),
+  submittedBy: z.string().optional().default("local-producer")
+});
+var updateViewInputSchema = z.object({
+  config: viewConfigSchema.optional(),
+  description: z.string().optional(),
+  message: z.string().optional().default("Update view"),
+  name: z.string().min(1).optional(),
+  submittedBy: z.string().optional().default("local-producer")
+});
+var deleteViewInputSchema = z.object({
+  message: z.string().optional().default("Delete view"),
+  submittedBy: z.string().optional().default("local-producer")
+});
+var restoreViewInputSchema = z.object({
+  message: z.string().optional().default("Restore view"),
+  submittedBy: z.string().optional().default("local-producer")
+});
+
+// ../../packages/busabase-contract/src/domains/base/contract/record-schemas.ts
+var recordSchema = z.object({
+  id: z.string(),
+  baseId: z.string(),
+  headCommitId: z.string(),
+  parentRecordId: z.string().nullable(),
+  parentCommitId: z.string().nullable(),
+  status: z.enum(["active", "archived"]),
+  createdBy: z.string(),
+  createdByUser: userRefSchema.nullable().optional().default(null),
+  archivedAt: z.string().nullable(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  base: baseSchema,
+  headCommit: commitSchema
+});
+var listRecordsFilterSchema = z.object({
+  fieldSlug: z.string(),
+  fieldType: z.string().optional(),
+  operator: viewFilterOperatorSchema,
+  value: z.unknown().optional()
+});
+var listRecordsSortSchema = z.object({
+  fieldSlug: z.string(),
+  fieldType: z.string().optional(),
+  direction: z.enum(["asc", "desc"]).optional().default("asc")
+});
+var listRecordsInputSchema = z.object({
+  limit: z.coerce.number().int().min(1).max(100).optional().default(50),
+  baseId: z.string().optional(),
+  /** Opaque base64 cursor for keyset pagination (createdAt-keyed, or sort-keyed when `sort` is set). */
+  cursor: z.string().optional(),
+  /** View filters for server-side push-down (superset; client still narrows). */
+  filters: z.array(listRecordsFilterSchema).optional(),
+  /** View sort for server-side push-down (number/date fields only). */
+  sort: listRecordsSortSchema.optional()
+}).optional().default({ limit: 50 });
+var listRecordsResponseSchema = z.object({
+  records: z.array(recordSchema),
+  nextCursor: z.string().nullable()
+});
+var countRecordsInputSchema = z.object({
+  baseId: z.string().optional()
+}).optional().default({});
+var countRecordsResponseSchema = z.object({
+  /** Total active records in the space (optionally scoped to a base). */
+  total: z.number().int().nonnegative()
+});
+var createChangeRequestInputSchema = z.object({
+  fields: z.record(z.string(), z.unknown()).describe(
+    "Record field values keyed by field slug. The base's PRIMARY field (its first field) becomes the record's display name and the change request title everywhere \u2014 always give it a short, human-readable value, never an id or placeholder."
+  ),
+  message: z.string().optional().default("Initial change request").describe(
+    'Explanation shown to the human reviewer. Write a conventional-commit style subject \u2014 imperative verb + what + why, e.g. "Add Acme Corp \u2014 qualified lead from the June webinar".'
+  ),
+  submittedBy: z.string().optional().default("local-producer")
+});
+var createBulkChangeRequestInputSchema = z.object({
+  records: z.array(z.record(z.string(), z.unknown())).min(1).max(1e3).describe(
+    "Field-value maps, one per record to create, each keyed by field slug. All records are proposed as a SINGLE change request (one review, one merge) \u2014 use this to import/seed many rows at once instead of one change request per record. Capped at 1000; for very large loads prefer a dedicated import job. Always give each record's PRIMARY field a short human-readable value."
+  ),
+  message: z.string().optional().default("Bulk create records").describe(
+    'Explanation shown to the human reviewer for the whole batch \u2014 e.g. "Import 240 June webinar leads".'
+  ),
+  submittedBy: z.string().optional().default("local-producer")
+});
+var recordFieldFilterInputSchema = z.object({
+  baseId: z.string().optional(),
+  fieldSlug: z.string().min(1),
+  valueText: z.string().min(1),
+  limit: z.coerce.number().int().min(1).max(100).optional().default(50)
+});
+var restoreRecordInputSchema = z.object({
+  message: z.string().optional(),
+  submittedBy: z.string().optional().default("local-editor")
+});
+var recordLinkSchema = z.object({
+  id: z.string(),
+  baseId: z.string(),
+  fieldId: z.string(),
+  fieldSlug: z.string(),
+  sourceRecordId: z.string(),
+  targetBaseId: z.string(),
+  targetRecordId: z.string(),
+  commitId: z.string(),
+  position: z.number(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+var baseContract = {
+  list: oc.route({
+    method: "GET",
+    path: "/bases",
+    tags: ["Bases"],
+    summary: "List Bases",
+    successDescription: "Flat list of developer-facing Bases."
+  }).output(z.array(baseSchema)),
+  listArchived: oc.route({
+    method: "GET",
+    path: "/bases/archived",
+    tags: ["Bases"],
+    summary: "List archived bases",
+    successDescription: "Bases that have been archived."
+  }).output(z.array(baseSchema)),
+  get: oc.route({
+    method: "GET",
+    path: "/bases/{baseId}",
+    tags: ["Bases"],
+    summary: "Get Base",
+    successDescription: "Single Base by id or slug."
+  }).input(z.object({ baseId: z.string() })).output(baseSchema.nullable()),
+  listDeletedFields: oc.route({
+    method: "GET",
+    path: "/bases/{baseId}/fields/deleted",
+    tags: ["Bases"],
+    summary: "List deleted fields",
+    successDescription: "Fields that have been soft-deleted from a Base."
+  }).input(z.object({ baseId: z.string() })).output(z.array(baseFieldSchema)),
+  listViews: oc.route({
+    method: "GET",
+    path: "/bases/{baseId}/views",
+    tags: ["Views"],
+    summary: "List active views for a Base",
+    successDescription: "Saved table views for a Base."
+  }).input(z.object({ baseId: z.string() })).output(z.array(viewSchema)),
+  listArchivedViews: oc.route({
+    method: "GET",
+    path: "/bases/{baseId}/views/archived",
+    tags: ["Views"],
+    summary: "List archived views for a Base",
+    successDescription: "Views that have been archived (soft-deleted) from a Base."
+  }).input(z.object({ baseId: z.string() })).output(z.array(viewSchema)),
+  listArchivedRecords: oc.route({
+    method: "GET",
+    path: "/bases/{baseId}/records/archived",
+    tags: ["Records"],
+    summary: "List archived records for a Base",
+    successDescription: "Records that have been archived (soft-deleted) from a Base."
+  }).input(z.object({ baseId: z.string() })).output(z.array(recordSchema)),
+  create: oc.route({
+    method: "POST",
+    path: "/bases",
+    tags: ["Bases"],
+    summary: "Create Base",
+    successDescription: "Created Base."
+  }).input(createBaseInputSchema).output(baseSchema),
+  createChangeRequest: oc.route({
+    method: "POST",
+    path: "/bases/{baseId}/change-requests",
+    tags: ["Bases", "Change Requests"],
+    summary: "Create Change Request in Base",
+    successDescription: "Created change request for review."
+  }).input(createChangeRequestInputSchema.extend({ baseId: z.string() })).output(changeRequestSchema),
+  createBulkChangeRequest: oc.route({
+    method: "POST",
+    path: "/bases/{baseId}/records/bulk-change-request",
+    tags: ["Bases", "Change Requests"],
+    summary: "Create bulk record Change Request in Base",
+    successDescription: "Created one change request proposing many record creates."
+  }).input(createBulkChangeRequestInputSchema.extend({ baseId: z.string() })).output(changeRequestSchema),
+  createField: oc.route({
+    method: "POST",
+    path: "/bases/{baseId}/fields",
+    tags: ["Bases"],
+    summary: "Create Base field",
+    successDescription: "Created Base field."
+  }).input(createBaseFieldInputSchema.extend({ baseId: z.string() })).output(baseSchema),
+  createFieldChangeRequest: oc.route({
+    method: "POST",
+    path: "/bases/{baseId}/fields/change-requests",
+    tags: ["Bases", "Change Requests"],
+    summary: "Create Add Field change request",
+    successDescription: "Created change request that proposes a new field."
+  }).input(createFieldChangeRequestInputSchema.extend({ baseId: z.string() })).output(changeRequestSchema),
+  createViewChangeRequest: oc.route({
+    method: "POST",
+    path: "/bases/{baseId}/views/change-requests",
+    tags: ["Views", "Change Requests"],
+    summary: "Create View change request",
+    successDescription: "Created change request that proposes a new View."
+  }).input(createViewInputSchema.extend({ baseId: z.string() })).output(changeRequestSchema),
+  deleteFieldChangeRequest: oc.route({
+    method: "DELETE",
+    path: "/bases/{baseId}/fields/change-requests",
+    tags: ["Bases", "Change Requests"],
+    summary: "Create Delete Field change request",
+    successDescription: "Created change request that soft-deletes a field."
+  }).input(deleteFieldChangeRequestInputSchema.extend({ baseId: z.string() })).output(changeRequestSchema),
+  updateFieldChangeRequest: oc.route({
+    method: "PATCH",
+    path: "/bases/{baseId}/fields/change-requests",
+    tags: ["Bases", "Change Requests"],
+    summary: "Create Update Field change request",
+    successDescription: "Created change request that updates field metadata (name, required, options)."
+  }).input(updateFieldChangeRequestInputSchema.extend({ baseId: z.string() })).output(changeRequestSchema),
+  previewFieldConversion: oc.route({
+    method: "POST",
+    path: "/bases/{baseId}/fields/convert/preview",
+    tags: ["Bases"],
+    summary: "Preview field type conversion",
+    successDescription: "Dry-run statistics for converting a field to a different type."
+  }).input(previewFieldConversionInputSchema.extend({ baseId: z.string() })).output(previewFieldConversionOutputSchema),
+  convertFieldChangeRequest: oc.route({
+    method: "POST",
+    path: "/bases/{baseId}/fields/convert/change-requests",
+    tags: ["Bases", "Change Requests"],
+    summary: "Create Convert Field change request",
+    successDescription: "Created change request that converts a field to a different type."
+  }).input(convertFieldChangeRequestInputSchema.extend({ baseId: z.string() })).output(changeRequestSchema),
+  reorderFieldsChangeRequest: oc.route({
+    method: "POST",
+    path: "/bases/{baseId}/fields/reorder/change-requests",
+    tags: ["Bases", "Change Requests"],
+    summary: "Reorder fields",
+    successDescription: "Created change request that reorders fields."
+  }).input(reorderFieldsChangeRequestInputSchema.extend({ baseId: z.string() })).output(changeRequestSchema),
+  archiveChangeRequest: oc.route({
+    method: "POST",
+    path: "/bases/{baseId}/archive/change-requests",
+    tags: ["Bases", "Change Requests"],
+    summary: "Archive base",
+    successDescription: "Created change request that archives a base."
+  }).input(archiveBaseInputSchema.extend({ baseId: z.string() })).output(changeRequestSchema),
+  restoreChangeRequest: oc.route({
+    method: "POST",
+    path: "/bases/{baseId}/restore/change-requests",
+    tags: ["Bases", "Change Requests"],
+    summary: "Restore base",
+    successDescription: "Created change request that restores an archived base."
+  }).input(restoreBaseInputSchema.extend({ baseId: z.string() })).output(changeRequestSchema),
+  restoreFieldChangeRequest: oc.route({
+    method: "POST",
+    path: "/bases/{baseId}/fields/restore/change-requests",
+    tags: ["Bases", "Change Requests"],
+    summary: "Restore deleted field",
+    successDescription: "Created change request that restores a soft-deleted field."
+  }).input(restoreFieldChangeRequestInputSchema.extend({ baseId: z.string() })).output(changeRequestSchema)
+};
+var recordContract = {
+  list: oc.route({
+    method: "GET",
+    path: "/records",
+    tags: ["Records"],
+    summary: "List records",
+    successDescription: "Canonical records created from merged change requests."
+  }).input(listInputSchema).output(z.array(recordSchema)),
+  listPaged: oc.route({
+    method: "GET",
+    path: "/records/paged",
+    tags: ["Records"],
+    summary: "List records with keyset pagination",
+    successDescription: "A page of canonical records plus an opaque nextCursor (null at the end)."
+  }).input(listRecordsInputSchema).output(listRecordsResponseSchema),
+  count: oc.route({
+    method: "GET",
+    path: "/records/count",
+    tags: ["Records"],
+    summary: "Count records",
+    successDescription: "Total active records in the space, optionally scoped to a base."
+  }).input(countRecordsInputSchema).output(countRecordsResponseSchema),
+  get: oc.route({
+    method: "GET",
+    path: "/records/{recordId}",
+    tags: ["Records"],
+    summary: "Get record",
+    successDescription: "Canonical record detail."
+  }).input(z.object({ recordId: z.string() })).output(recordSchema),
+  search: oc.route({
+    method: "GET",
+    path: "/records/search",
+    tags: ["Records"],
+    summary: "Filter records by field text",
+    successDescription: "Canonical records matching a field text filter."
+  }).input(recordFieldFilterInputSchema).output(z.array(recordSchema)),
+  updateChangeRequest: oc.route({
+    method: "PUT",
+    path: "/records/{recordId}/change-requests",
+    tags: ["Records", "Change Requests"],
+    summary: "Create record update change request",
+    successDescription: "Created change request that proposes updating a canonical record."
+  }).input(reviseOperationInputSchema.extend({ recordId: z.string() })).output(changeRequestSchema),
+  deleteChangeRequest: oc.route({
+    method: "DELETE",
+    path: "/records/{recordId}/change-requests",
+    tags: ["Records", "Change Requests"],
+    summary: "Create record delete change request",
+    successDescription: "Created change request that proposes archiving or deleting a record."
+  }).input(createDeleteChangeRequestInputSchema.extend({ recordId: z.string() })).output(changeRequestSchema),
+  listChangeRequests: oc.route({
+    method: "GET",
+    path: "/records/{recordId}/change-requests",
+    tags: ["Records", "Change Requests"],
+    summary: "List record change request history",
+    successDescription: "Change requests and operations connected to the canonical record."
+  }).input(z.object({ recordId: z.string() })).output(z.array(changeRequestSchema)),
+  restoreChangeRequest: oc.route({
+    method: "POST",
+    path: "/records/{recordId}/restore/change-requests",
+    tags: ["Records", "Change Requests"],
+    summary: "Create record restore change request",
+    successDescription: "Created change request that restores an archived record."
+  }).input(restoreRecordInputSchema.extend({ recordId: z.string() })).output(changeRequestSchema),
+  listLinks: oc.route({
+    method: "GET",
+    path: "/records/{recordId}/links",
+    tags: ["Records"],
+    summary: "List record links",
+    successDescription: "Active outbound links from a canonical record."
+  }).input(z.object({ recordId: z.string() })).output(z.array(recordLinkSchema))
+};
+var viewContract = {
+  updateChangeRequest: oc.route({
+    method: "PUT",
+    path: "/views/{viewId}/change-requests",
+    tags: ["Views", "Change Requests"],
+    summary: "Create View update change request",
+    successDescription: "Created change request that proposes updating a View."
+  }).input(updateViewInputSchema.extend({ viewId: z.string() })).output(changeRequestSchema),
+  deleteChangeRequest: oc.route({
+    method: "DELETE",
+    path: "/views/{viewId}/change-requests",
+    tags: ["Views", "Change Requests"],
+    summary: "Create View delete change request",
+    successDescription: "Created change request that proposes archiving a View."
+  }).input(deleteViewInputSchema.extend({ viewId: z.string() })).output(changeRequestSchema),
+  restoreChangeRequest: oc.route({
+    method: "POST",
+    path: "/views/{viewId}/restore/change-requests",
+    tags: ["Views", "Change Requests"],
+    summary: "Create View restore change request",
+    successDescription: "Created change request that restores an archived View."
+  }).input(restoreViewInputSchema.extend({ viewId: z.string() })).output(changeRequestSchema)
+};
+var docSchema = z.object({
+  node: nodeSchema,
+  storagePrefix: z.string(),
+  body: z.string()
+});
+var createDocInputSchema = z.object({
+  parentNodeId: z.string().optional(),
+  slug: z.string().min(1).regex(/^[a-z0-9-]+$/),
+  name: z.string().min(1),
+  description: z.string().optional().default(""),
+  body: z.string().optional().default("")
+});
+var updateDocInputSchema = z.object({
+  body: z.string()
+});
+var createDocChangeRequestInputSchema = z.object({
+  body: z.string(),
+  message: z.string().optional().default("Update doc").describe(
+    'Explanation shown to the human reviewer. Write a conventional-commit style subject \u2014 imperative verb + what + why, e.g. "Add rollback steps to the deploy runbook".'
+  ),
+  submittedBy: z.string().optional().default("local-producer")
+});
+var docContract = {
+  list: oc.route({
+    method: "GET",
+    path: "/docs",
+    tags: ["Docs"],
+    summary: "List Doc nodes",
+    successDescription: "Doc nodes with their storage-backed bodies."
+  }).output(z.array(docSchema)),
+  create: oc.route({
+    method: "POST",
+    path: "/docs",
+    tags: ["Docs"],
+    summary: "Create Doc node",
+    successDescription: "Created Doc node and initialized its body."
+  }).input(createDocInputSchema).output(docSchema),
+  get: oc.route({
+    method: "GET",
+    path: "/docs/{nodeId}",
+    tags: ["Docs"],
+    summary: "Get Doc node",
+    successDescription: "Doc node detail and body."
+  }).input(z.object({ nodeId: z.string() })).output(docSchema),
+  updateBody: oc.route({
+    method: "PUT",
+    path: "/docs/{nodeId}/body",
+    tags: ["Docs"],
+    summary: "Update Doc body",
+    successDescription: "Updated the Doc body."
+  }).input(updateDocInputSchema.extend({ nodeId: z.string() })).output(docSchema),
+  createChangeRequest: oc.route({
+    method: "POST",
+    path: "/docs/{nodeId}/change-requests",
+    tags: ["Docs", "Change Requests"],
+    summary: "Create Doc change request",
+    successDescription: "Created a change request that proposes a new Doc body."
+  }).input(createDocChangeRequestInputSchema.extend({ nodeId: z.string() })).output(changeRequestSchema)
+};
+var fileTreeFileSchema = z.object({
+  path: z.string(),
+  name: z.string(),
+  size: z.number(),
+  updatedAt: z.string().nullable(),
+  mimeType: z.string().nullable(),
+  assetId: z.string(),
+  displayName: z.string().nullable()
+});
+var assetFileInputSchema = z.object({
+  path: z.string().min(1),
+  assetId: z.string().min(1),
+  displayName: z.string().optional(),
+  mimeType: z.string().optional()
+}).strict();
+var textFileInputSchema = z.object({
+  path: z.string().min(1),
+  content: z.string().default(""),
+  mimeType: z.string().optional()
+}).strict();
+var assetFileOperationInputSchema = z.object({
+  kind: z.enum(["create", "update"]),
+  path: z.string().min(1),
+  assetId: z.string().min(1),
+  displayName: z.string().optional(),
+  mimeType: z.string().optional(),
+  baseContentHash: z.string().optional()
+}).strict();
+var textFileOperationInputSchema = z.object({
+  kind: z.enum(["create", "update"]),
+  path: z.string().min(1),
+  content: z.string(),
+  mimeType: z.string().optional(),
+  baseContentHash: z.string().optional()
+}).strict();
+var fileTreeNodeSchema = z.object({
+  node: nodeSchema,
+  entryFile: z.string(),
+  visibility: z.enum(["private", "workspace", "public"]),
+  version: z.string(),
+  files: z.array(fileTreeFileSchema)
+});
+var createFileTreeInputSchema = z.object({
+  parentNodeId: z.string().optional(),
+  slug: z.string().min(1).regex(/^[a-z0-9-]+$/),
+  name: z.string().min(1),
+  description: z.string().optional().default(""),
+  visibility: z.enum(["private", "workspace", "public"]).optional().default("private"),
+  version: z.string().optional().default("0.1.0"),
+  files: z.array(z.union([assetFileInputSchema, textFileInputSchema])).optional().default([])
+});
+var fileTreeFileOperationInputSchema = z.union([
+  assetFileOperationInputSchema,
+  textFileOperationInputSchema,
+  z.object({
+    kind: z.literal("delete"),
+    path: z.string().min(1),
+    baseContentHash: z.string().optional()
+  }).strict(),
+  z.object({
+    kind: z.literal("metadata_update"),
+    metadata: z.object({
+      entryFile: z.string().optional(),
+      visibility: z.enum(["private", "workspace", "public"]).optional(),
+      version: z.string().optional()
+    }).default({})
+  }).strict()
+]);
+var createFileTreeChangeRequestInputSchema = z.object({
+  message: z.string().optional().default("Update file tree").describe(
+    'Explanation shown to the human reviewer. Write a conventional-commit style subject \u2014 imperative verb + what + why, e.g. "Rewrite README.md quickstart for the new auth flow".'
+  ),
+  submittedBy: z.string().optional().default("local-producer"),
+  operations: z.array(fileTreeFileOperationInputSchema).min(1)
+});
+var makeFileTreeContract = (routeBase, tag) => {
+  const label = tag.endsWith("s") ? tag.slice(0, -1) : tag;
+  const basePath = `/${routeBase}`;
+  return {
+    list: oc.route({
+      method: "GET",
+      path: basePath,
+      tags: [tag],
+      summary: `List ${label} nodes`,
+      successDescription: `${label} nodes with their Asset-backed file trees.`
+    }).output(z.array(fileTreeNodeSchema)),
+    create: oc.route({
+      method: "POST",
+      path: basePath,
+      tags: [tag],
+      summary: `Create ${label} node`,
+      successDescription: `Created ${label} node and initialized file tree.`
+    }).input(createFileTreeInputSchema).output(fileTreeNodeSchema),
+    get: oc.route({
+      method: "GET",
+      path: `${basePath}/{nodeId}`,
+      tags: [tag],
+      summary: `Get ${label} node`,
+      successDescription: `${label} node detail and file tree.`
+    }).input(z.object({ nodeId: z.string() })).output(fileTreeNodeSchema),
+    listFiles: oc.route({
+      method: "GET",
+      path: `${basePath}/{nodeId}/files`,
+      tags: [tag],
+      summary: `List ${label} files`,
+      successDescription: `Asset-backed files mounted under the ${label} node.`
+    }).input(z.object({ nodeId: z.string() })).output(z.array(fileTreeFileSchema)),
+    readFile: oc.route({
+      method: "GET",
+      path: `${basePath}/{nodeId}/files/{+filePath}`,
+      tags: [tag],
+      summary: `Read ${label} file`,
+      successDescription: `${label} file content and content hash.`
+    }).input(z.object({ nodeId: z.string(), filePath: z.string() })).output(
+      z.object({
+        nodeId: z.string(),
+        path: z.string(),
+        encoding: z.enum(["utf8", "url"]),
+        content: z.string(),
+        mimeType: z.string(),
+        assetId: z.string(),
+        displayName: z.string().nullable(),
+        assetUrl: z.string().nullable(),
+        contentHash: z.string()
+      })
+    ),
+    createChangeRequest: oc.route({
+      method: "POST",
+      path: `${basePath}/{nodeId}/change-requests`,
+      tags: [tag, "Change Requests"],
+      summary: `Create ${label} change request`,
+      successDescription: `Created file-tree change request for a ${label} node.`
+    }).input(createFileTreeChangeRequestInputSchema.extend({ nodeId: z.string() })).output(changeRequestSchema)
+  };
+};
+
+// ../../packages/busabase-contract/src/domains/drive/contract.ts
+var driveContract = makeFileTreeContract("drives", "Drives");
+z.object({
+  assetId: z.string()
+});
+var FileNodeVOSchema = z.object({
+  node: nodeSchema,
+  asset: AssetVOSchema
+});
+
+// ../../packages/busabase-contract/src/domains/file-node/contract.ts
+var createFileNodeInputSchema = z.object({
+  parentNodeId: z.string().optional(),
+  slug: z.string().min(1).regex(/^[a-z0-9-]+$/),
+  name: z.string().min(1),
+  description: z.string().optional().default(""),
+  assetId: z.string().min(1)
+});
+var fileContract = {
+  list: oc.route({
+    method: "GET",
+    path: "/files",
+    tags: ["Files"],
+    summary: "List File nodes",
+    successDescription: "Workspace File nodes with their backing Asset metadata."
+  }).output(z.array(FileNodeVOSchema)),
+  create: oc.route({
+    method: "POST",
+    path: "/files",
+    tags: ["Files"],
+    summary: "Create File node",
+    successDescription: "Created a first-class File node that references an Asset."
+  }).input(createFileNodeInputSchema).output(FileNodeVOSchema),
+  get: oc.route({
+    method: "GET",
+    path: "/files/{nodeId}",
+    tags: ["Files"],
+    summary: "Get File node",
+    successDescription: "File node detail and backing Asset metadata."
+  }).input(z.object({ nodeId: z.string() })).output(FileNodeVOSchema)
+};
+var folderSchema = z.object({
+  node: nodeSchema,
+  children: z.array(nodeSchema)
+});
+var folderContract = {
+  list: oc.route({
+    method: "GET",
+    path: "/folders",
+    tags: ["Folders"],
+    summary: "List Folder nodes",
+    successDescription: "Folder nodes with their direct children."
+  }).output(z.array(folderSchema)),
+  get: oc.route({
+    method: "GET",
+    path: "/folders/{nodeId}",
+    tags: ["Folders"],
+    summary: "Get Folder node",
+    successDescription: "Folder node and its direct children."
+  }).input(z.object({ nodeId: z.string() })).output(folderSchema)
+};
+
+// ../../packages/busabase-contract/src/domains/skill/contract.ts
+var skillContract = makeFileTreeContract("skills", "Skills");
+var VaultItemKeySchema = z.string().trim().min(1).max(128).regex(/^[A-Z_][A-Z0-9_]*$/, "Use uppercase letters, numbers, and underscores");
+var VaultItemValueSchema = z.string().max(8192);
+var VaultItemKindSchema = z.enum(["secret", "variable"]);
+var VaultScopeTypeSchema = z.enum([
+  "personal",
+  "workspace",
+  "base",
+  "agent",
+  "tool",
+  "api_key"
+]);
+var VaultEnvironmentSchema = z.enum(["local", "development", "staging", "production"]);
+var VaultAccessPolicySchema = z.object({
+  runtime: z.boolean().default(true),
+  reveal: z.boolean().default(true),
+  edit: z.boolean().default(true),
+  share: z.boolean().default(false)
+});
+var VaultItemInputSchema = z.object({
+  id: z.string().optional(),
+  kind: VaultItemKindSchema,
+  key: VaultItemKeySchema,
+  value: VaultItemValueSchema,
+  scopeType: VaultScopeTypeSchema.default("personal"),
+  scopeId: z.string().trim().nullable().optional(),
+  environment: VaultEnvironmentSchema.default("local"),
+  description: z.string().trim().max(512).default(""),
+  access: VaultAccessPolicySchema.default({
+    runtime: true,
+    reveal: true,
+    edit: true,
+    share: false
+  })
+});
+var UpdateVaultSettingsInputSchema = z.object({
+  items: z.array(VaultItemInputSchema).max(200)
+});
+var VaultItemVOSchema = VaultItemInputSchema.extend({
+  id: z.string(),
+  scopeId: z.string().nullable(),
+  updatedAt: z.string(),
+  createdAt: z.string(),
+  lastUsedAt: z.string().nullable()
+});
+var VaultSettingsVOSchema = z.object({
+  ownerId: z.string().nullable(),
+  items: z.array(VaultItemVOSchema),
+  updatedAt: z.string().nullable()
+});
+z.record(VaultItemKeySchema, VaultItemValueSchema).default({});
+var VaultSuccessSchema = z.object({ success: z.boolean() });
+
+// ../../packages/busabase-contract/src/domains/vault/contract.ts
+var vaultContract = {
+  get: oc.route({
+    method: "GET",
+    path: "/vault",
+    tags: ["Vault"],
+    summary: "Get local Vault settings",
+    successDescription: "Local Vault secrets and variables for this Busabase instance."
+  }).output(VaultSettingsVOSchema),
+  update: oc.route({
+    method: "PUT",
+    path: "/vault",
+    tags: ["Vault"],
+    summary: "Replace local Vault settings",
+    successDescription: "Updated local Vault secrets and variables."
+  }).input(UpdateVaultSettingsInputSchema).output(VaultSettingsVOSchema),
+  clear: oc.route({
+    method: "DELETE",
+    path: "/vault",
+    tags: ["Vault"],
+    summary: "Clear local Vault settings",
+    successDescription: "Removed local Vault secrets and variables."
+  }).output(VaultSuccessSchema)
+};
+
+// ../../packages/busabase-contract/src/contract/busabase.ts
+var changeRequestBatchResultSchema = z.object({
+  results: z.array(
+    z.object({
+      changeRequestId: z.string(),
+      ok: z.boolean(),
+      status: z.string().optional(),
+      error: z.string().optional()
+    })
+  )
+});
+var busabaseContractRoutes = {
+  auth: {
+    verify: oc.route({
+      method: "GET",
+      path: "/auth",
+      tags: ["Auth"],
+      summary: "Verify auth and get the targeted space, user, membership, and all spaces",
+      successDescription: "The space this request targets, the acting user, their membership, and every space the user belongs to (`spaces`). Open source returns the local space/user; the cloud resolves the real ones from the user API key \u2014 when `spaces` has more than one entry, target a specific space with the `x-busabase-space` header instead of relying on the default."
+    }).output(authInfoSchema)
+  },
+  search: oc.route({
+    method: "GET",
+    path: "/search",
+    tags: ["Search"],
+    summary: "Search Busabase",
+    successDescription: "Paginated search results across records, change requests, Bases, File nodes, and Assets."
+  }).input(searchInputSchema).output(searchResponseSchema),
+  nodes: {
+    list: oc.route({
+      method: "GET",
+      path: "/nodes",
+      tags: ["Nodes"],
+      summary: "List node tree",
+      successDescription: "Workspace node tree including folders, Bases, files, and agents."
+    }).output(z.array(nodeSchema)),
+    listArchived: oc.route({
+      method: "GET",
+      path: "/nodes/archived",
+      tags: ["Nodes"],
+      summary: "List archived nodes",
+      successDescription: "Soft-archived folders, docs, and skills (for the Trash view)."
+    }).output(z.array(nodeSchema)),
+    createChangeRequest: oc.route({
+      method: "POST",
+      path: "/nodes/change-requests",
+      tags: ["Nodes", "Change Requests"],
+      summary: "Create Node tree change request",
+      successDescription: "Created change request for folder or node tree changes."
+    }).input(createNodeChangeRequestInputSchema).output(changeRequestSchema),
+    purge: oc.route({
+      method: "DELETE",
+      path: "/nodes/{nodeId}",
+      tags: ["Nodes"],
+      summary: "Permanently delete an archived node",
+      successDescription: "Irreversibly removed an archived folder/doc/skill (and its subtree). Refused unless archived and refused if the subtree contains a Base."
+    }).input(z.object({ nodeId: z.string() })).output(z.object({ purged: z.boolean() }))
+  },
+  auditEvents: {
+    list: oc.route({
+      method: "GET",
+      path: "/audit-events",
+      tags: ["Audit"],
+      summary: "List audit events",
+      successDescription: "Recent non-mutating and workflow audit events."
+    }).input(listInputSchema).output(z.array(auditEventSchema)),
+    create: oc.route({
+      method: "POST",
+      path: "/audit-events",
+      tags: ["Audit"],
+      summary: "Create audit event",
+      successDescription: "Recorded audit event."
+    }).input(createAuditEventInputSchema).output(auditEventSchema)
+  },
+  comments: {
+    list: oc.route({
+      method: "GET",
+      path: "/comments",
+      tags: ["Comments"],
+      summary: "List comments",
+      successDescription: "Comments attached to a Busabase subject."
+    }).input(commentSubjectInputSchema).output(z.array(commentSchema)),
+    create: oc.route({
+      method: "POST",
+      path: "/comments",
+      tags: ["Comments"],
+      summary: "Create comment",
+      successDescription: "Created comment attached to a Busabase subject."
+    }).input(createCommentInputSchema).output(commentSchema)
+  },
+  agent: {
+    listTasks: oc.route({
+      method: "GET",
+      path: "/agent/tasks",
+      tags: ["Agent"],
+      summary: "List agent revision tasks",
+      successDescription: "Change requests awaiting an external agent (request-changes or @ai mentions)."
+    }).output(z.array(agentTaskSchema))
+  },
+  live: {
+    // RPC-only by design: no `.route(...)`, so OpenAPI generation and MCP tool
+    // discovery skip this long-lived Event Iterator while `/api/rpc` stays typed.
+    subscribe: oc.output(eventIterator(liveEventSchema))
+  },
+  bases: baseContract,
+  skills: skillContract,
+  drives: driveContract,
+  files: fileContract,
+  docs: docContract,
+  folders: folderContract,
+  assets: assetsContract,
+  vault: vaultContract,
+  changeRequests: {
+    list: oc.route({
+      method: "GET",
+      path: "/change-requests",
+      tags: ["Change Requests"],
+      summary: "List change requests",
+      successDescription: "Change requests waiting for review or ready to merge."
+    }).input(listInputSchema).output(z.array(changeRequestSchema)),
+    listPaged: oc.route({
+      method: "GET",
+      path: "/change-requests/paged",
+      tags: ["Change Requests"],
+      summary: "List change requests with keyset pagination",
+      successDescription: "A page of change requests plus an opaque nextCursor (null at the end). Filter with `status` and/or `mine`."
+    }).input(listChangeRequestsPagedInputSchema).output(listChangeRequestsResponseSchema),
+    counts: oc.route({
+      method: "GET",
+      path: "/change-requests/counts",
+      tags: ["Change Requests"],
+      summary: "Count change requests by inbox tab",
+      successDescription: "Whole-space change request counts per inbox tab (review / changes / created / approved / merged / rejected)."
+    }).output(changeRequestCountsSchema),
+    get: oc.route({
+      method: "GET",
+      path: "/change-requests/{changeRequestId}",
+      tags: ["Change Requests"],
+      summary: "Get change request",
+      successDescription: "Change Request detail."
+    }).input(z.object({ changeRequestId: z.string() })).output(changeRequestSchema),
+    review: oc.route({
+      method: "POST",
+      path: "/change-requests/{changeRequestId}/reviews",
+      tags: ["Change Requests"],
+      summary: "Review change request",
+      successDescription: "Reviewed change request."
+    }).input(reviewChangeRequestInputSchema.extend({ changeRequestId: z.string() })).output(changeRequestSchema),
+    reviewMany: oc.route({
+      method: "POST",
+      path: "/change-requests/reviews",
+      tags: ["Change Requests"],
+      summary: "Review many change requests",
+      successDescription: "Per-change-request review results (failures isolated \u2014 one bad id does not abort the rest)."
+    }).input(
+      reviewChangeRequestInputSchema.extend({
+        changeRequestIds: z.array(z.string()).min(1).max(100)
+      })
+    ).output(changeRequestBatchResultSchema),
+    close: oc.route({
+      method: "POST",
+      path: "/change-requests/{changeRequestId}/close",
+      tags: ["Change Requests"],
+      summary: "Close change request",
+      successDescription: "Closed change request (terminal \u2014 distinct from request changes)."
+    }).input(z.object({ changeRequestId: z.string(), reason: z.string().optional() })).output(changeRequestSchema),
+    merge: oc.route({
+      method: "POST",
+      path: "/change-requests/{changeRequestId}/merge",
+      tags: ["Change Requests"],
+      summary: "Merge change request into Base",
+      successDescription: "Merged change request and canonical record."
+    }).input(z.object({ changeRequestId: z.string() })).output(
+      z.object({
+        changeRequest: changeRequestSchema,
+        record: recordSchema.nullable(),
+        view: viewSchema.nullable()
+      })
+    ),
+    mergeMany: oc.route({
+      method: "POST",
+      path: "/change-requests/merge",
+      tags: ["Change Requests"],
+      summary: "Merge many change requests",
+      successDescription: "Per-change-request merge results (each merged in its own transaction; failures isolated)."
+    }).input(z.object({ changeRequestIds: z.array(z.string()).min(1).max(100) })).output(changeRequestBatchResultSchema)
+  },
+  operations: {
+    revise: oc.route({
+      method: "POST",
+      path: "/operations/{operationId}/revisions",
+      tags: ["Operations", "Change Requests"],
+      summary: "Revise operation",
+      successDescription: "Appended a new commit to the operation and moved the operation head."
+    }).input(reviseOperationInputSchema.extend({ operationId: z.string() })).output(changeRequestSchema)
+  },
+  records: recordContract,
+  views: viewContract
+};
+oc.prefix("/api/v1").router(busabaseContractRoutes);
+
+// ../../packages/busabase-contract/src/contract/cloud.ts
+var ErrorResponseSchema = z.object({
+  error: z.string()
+});
+var HealthResponseSchema = z.object({
+  status: z.string(),
+  timestamp: z.string()
+});
+var MetaResponseSchema = z.object({
+  service: z.string(),
+  version: z.string(),
+  timestamp: z.number()
+});
+var UserMeResponseSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  email: z.string(),
+  emailVerified: z.boolean(),
+  image: z.string().nullable(),
+  createdAt: z.string()
+});
+var AgentTaskStatusSchema = z.enum([
+  "pending",
+  "in_progress",
+  "completed",
+  "failed",
+  "cancelled"
+]);
+var AgentTaskListItemSchema = z.object({
+  id: z.union([z.string(), z.number()]),
+  title: z.string(),
+  description: z.string().nullable(),
+  status: z.string(),
+  priority: z.string(),
+  createdAt: z.string(),
+  completedAt: z.string().nullable()
+});
+var AgentTaskDetailSchema = AgentTaskListItemSchema.extend({
+  result: z.string().nullable()
+});
+var authenticatedErrors = {
+  UNAUTHORIZED: {
+    status: 401,
+    message: "Unauthorized",
+    data: ErrorResponseSchema
+  }
+};
+var notFoundErrors = {
+  NOT_FOUND: {
+    status: 404,
+    message: "Not Found",
+    data: ErrorResponseSchema
+  }
+};
+var { vault: _localVault, ...cloudWorkbenchRoutes } = busabaseContractRoutes;
+var cloudExtraRoutes = {
+  system: {
+    health: oc.route({
+      method: "GET",
+      path: "/health",
+      tags: ["System"],
+      summary: "Service health status",
+      successDescription: "Service health status"
+    }).output(HealthResponseSchema),
+    meta: oc.route({
+      method: "GET",
+      path: "/meta",
+      tags: ["System"],
+      summary: "Service metadata",
+      successDescription: "Service metadata"
+    }).output(MetaResponseSchema)
+  },
+  users: {
+    me: oc.route({
+      method: "GET",
+      path: "/users/me",
+      tags: ["Users"],
+      summary: "Get authenticated user",
+      successDescription: "Authenticated user information",
+      spec: (operation) => ({
+        ...operation,
+        security: [{ bearerAuth: [] }]
+      })
+    }).errors(authenticatedErrors).output(UserMeResponseSchema)
+  },
+  agentTasks: {
+    list: oc.route({
+      method: "GET",
+      path: "/agent-tasks",
+      tags: ["Agent Tasks"],
+      summary: "List agent tasks",
+      successDescription: "List of agent tasks",
+      inputStructure: "detailed",
+      spec: (operation) => ({
+        ...operation,
+        security: [{ bearerAuth: [] }]
+      })
+    }).errors(authenticatedErrors).input(
+      z.object({
+        query: z.object({
+          limit: z.string().optional(),
+          offset: z.string().optional(),
+          status: AgentTaskStatusSchema.optional()
+        })
+      })
+    ).output(
+      z.object({
+        tasks: z.array(AgentTaskListItemSchema),
+        total: z.number()
+      })
+    ),
+    get: oc.route({
+      method: "GET",
+      path: "/agent-tasks/{id}",
+      tags: ["Agent Tasks"],
+      summary: "Get agent task",
+      successDescription: "Agent task details",
+      inputStructure: "detailed",
+      spec: (operation) => ({
+        ...operation,
+        security: [{ bearerAuth: [] }]
+      })
+    }).errors({
+      ...authenticatedErrors,
+      ...notFoundErrors
+    }).input(
+      z.object({
+        params: z.object({
+          id: z.string()
+        })
+      })
+    ).output(AgentTaskDetailSchema)
+  }
+};
+var cloudContract = oc.prefix("/api/v1").router({
+  ...cloudWorkbenchRoutes,
+  ...cloudExtraRoutes
+});
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://busabase.com";
+var env = (key) => {
+  if (typeof process === "undefined" || !process.env) {
+    return void 0;
+  }
+  const value = process.env[key];
+  return value && value.length > 0 ? value : void 0;
+};
+function normalizeBaseUrl(raw) {
+  return raw.replace(/\/+$/, "").replace(/\/api\/v1$/, "");
+}
+function resolveConfig(config = {}) {
+  return {
+    baseUrl: normalizeBaseUrl(config.baseUrl ?? env("BUSABASE_BASE_URL") ?? DEFAULT_BASE_URL),
+    apiKey: config.apiKey ?? env("BUSABASE_API_KEY"),
+    spaceId: config.spaceId ?? env("BUSABASE_SPACE_ID"),
+    headers: config.headers,
+    fetch: config.fetch
+  };
+}
+function createBusabaseClient(config = {}) {
+  const resolved = resolveConfig(config);
+  const link = new OpenAPILink(cloudContract, {
+    url: resolved.baseUrl,
+    fetch: resolved.fetch,
+    headers: async () => {
+      const extra = typeof resolved.headers === "function" ? await resolved.headers() : resolved.headers;
+      return {
+        ...resolved.apiKey ? { authorization: `Bearer ${resolved.apiKey}` } : {},
+        ...resolved.spaceId ? { "x-busabase-space": resolved.spaceId } : {},
+        ...extra
+      };
+    }
+  });
+  return createORPCClient(link);
+}
+
+// src/index.ts
+var Busabase = class {
+  /** The underlying fully-typed oRPC client. Use it for anything not surfaced here. */
+  client;
+  /** The config after env / default resolution (base URL, presence of a key, space). */
+  config;
+  constructor(config = {}) {
+    this.config = resolveConfig(config);
+    this.client = createBusabaseClient(this.config);
+  }
+  // Namespaced domain surfaces — delegate to the raw client so callers get the
+  // exact same typing as `client.<ns>` but through a single `Busabase` instance.
+  get bases() {
+    return this.client.bases;
+  }
+  get records() {
+    return this.client.records;
+  }
+  get views() {
+    return this.client.views;
+  }
+  get changeRequests() {
+    return this.client.changeRequests;
+  }
+  get operations() {
+    return this.client.operations;
+  }
+  get nodes() {
+    return this.client.nodes;
+  }
+  get comments() {
+    return this.client.comments;
+  }
+  get auditEvents() {
+    return this.client.auditEvents;
+  }
+  get agent() {
+    return this.client.agent;
+  }
+  get assets() {
+    return this.client.assets;
+  }
+  get skills() {
+    return this.client.skills;
+  }
+  get drives() {
+    return this.client.drives;
+  }
+  get files() {
+    return this.client.files;
+  }
+  get docs() {
+    return this.client.docs;
+  }
+  get folders() {
+    return this.client.folders;
+  }
+  get agentTasks() {
+    return this.client.agentTasks;
+  }
+  /** Full-text search across records, change requests, and Bases. */
+  search(input) {
+    return this.client.search(input);
+  }
+  /** Service health — reaches the server without requiring auth. */
+  health() {
+    return this.client.system.health();
+  }
+  /** The authenticated user behind the configured API key (cloud only). */
+  me() {
+    return this.client.users.me();
+  }
+};
+
+export { Busabase, DEFAULT_BASE_URL, cloudContract, createBusabaseClient, normalizeBaseUrl, resolveConfig };