@work-shape/catalyst-asset-schemas 0.8.0-rc.3 → 0.8.0-rc.5

package/dist/index.js

@@ -1,4 +1,5 @@
 // src/asset-types.ts
+var ASSET_ACCESS_VERBS = ["read", "write", "delete", "publish"];
 var localeCodes = ["en", "de"];
 var REASONING_EFFORTS = ["none", "low", "medium", "high", "xhigh", "max"];
 var SKILL_STARTERS_MAX = 2;
@@ -12,6 +13,7 @@ var SKILL_RESOURCE_MEDIA_TYPES = [
   "application/json",
   "application/yaml"
 ];
+var APP_AUDIENCES = ["self", "workspace", "instance"];
 
 // src/contract-values.ts
 var AUTH_SCOPE_WILDCARD = "*";
@@ -83,16 +85,23 @@ var ACTIONS = [
   "data_store.delete",
   "data_store.insert",
   "data_store.execute",
+  "data_store.records",
   "knowledge_base.read",
   "knowledge_base.write",
   "knowledge_base.publish",
   "knowledge_base.delete",
   "knowledge_base.use",
+  // Sending e-mail as one sender of the instance (`mail.send`). The `admin` role holds it on
+  // the sender `system`; a member only by a grant.
+  "mail_sender.use",
   "guardrail.read",
   "guardrail.write",
   "guardrail.publish",
   "guardrail.delete",
   "operations.approve",
+  // Reading the written feedback on agent messages and marking it handled (LU-4): on the
+  // instance, or on one workspace for the agents it owns. No bundle carries it.
+  "feedback.review",
   "users.manage",
   "usage.view",
   "audit.view",
@@ -101,11 +110,11 @@ var ACTIONS = [
   // Their keys stay with `api_access.manage`.
   "service_principals.manage",
   "agent_models.manage",
-  "assets.release"
+  "assets.release",
+  // The two bundles of a workspace: one row each, expanded by the evaluator (`bundleCarries`).
+  "builder",
+  "publisher"
 ];
-var NAMESPACE_PREFIX_PATTERN = /^[a-z][a-z0-9]*(-[a-z0-9]+)*-$/u;
-var NAMESPACE_PREFIX_MIN_LENGTH = 2;
-var NAMESPACE_PREFIX_MAX_LENGTH = 32;
 var APP_ERROR_STATUS_CODES = {
   BAD_REQUEST: 400,
   UNAUTHENTICATED: 401,
@@ -152,13 +161,31 @@ var CONNECTION_HEALTH_STATES = [
   "secret_unreadable"
 ];
 var GRANT_HOLDER_KINDS = ["user", "service_principal", "role", "group"];
-var GRANT_SCOPE_KINDS = ["instance", "workspace", "namespace", "asset"];
+var GRANT_SCOPE_KINDS = ["instance", "workspace", "asset"];
+var ROLE_GRANT_SCOPE_KINDS = [
+  "instance",
+  "workspace",
+  "asset"
+];
+var ROLE_PENDING_CHANGES = ["added", "removed"];
+var ROLE_PENDING_DECISIONS = ["apply", "dismiss"];
 var GRANT_EFFECTS = ["allow", "deny"];
 var ACCESS_SOURCES = ["role", "legacy_ref", "grant", "membership"];
 var POLICY_VALUES = ["allow", "confirm", "approval", "deny"];
 var AUTH_PRINCIPAL_KINDS = ["user", "service"];
 var ADMINISTERED_USER_STATUSES = ["active", "disabled", "deleting"];
 var SERVICE_PRINCIPAL_STATUSES = ["active", "disabled"];
+var WORKFLOW_RIGHT_NEEDED_FOR = ["publish", "run"];
+var WORKFLOW_RIGHTS_REVISIONS = ["draft", "published"];
+var WORKFLOW_RUN_ACCOUNT_STATUSES = [...SERVICE_PRINCIPAL_STATUSES, "unknown"];
+var WORKFLOW_RIGHT_REFUSALS = [
+  "not_grantable",
+  "not_administrator",
+  "not_held",
+  "account_unavailable",
+  "asset_unavailable",
+  "not_visible"
+];
 var SERVICE_PRINCIPAL_PERMISSIONS = [
   "config_assets.read",
   "config_assets.release"
@@ -453,10 +480,11 @@ var DATA_STORE_STATUSES = ["provisioning", "ready", "retired"];
 var DATA_STORE_MIGRATION_OUTCOMES = ["none", "pending", "applied", "failed"];
 var KNOWLEDGE_BASE_STATUSES = ["unchecked", "preparing", "ok", "needs_attention"];
 var KNOWLEDGE_DOCUMENT_STATES = ["pending", "indexed", "failed"];
+var KNOWLEDGE_FILE_MAX_BYTES = 25 * 1024 * 1024;
 var KNOWLEDGE_DOCUMENT_FAILURE_CODES = [
   // The extractor does not read the file's format.
   "knowledge_file_format_unsupported",
-  // The file is over a limit of the extraction: size, pages or time.
+  // The file is over a limit of the extraction: its size or the size of its text.
   "knowledge_file_over_limit",
   // The file is corrupt, encrypted, or not the format it claims.
   "knowledge_file_unreadable",
@@ -471,7 +499,14 @@ var KNOWLEDGE_DOCUMENT_FAILURE_CODES = [
   // No text to search, such as a scanned PDF without a text layer.
   "knowledge_text_empty",
   // Indexing failed on every attempt.
-  "knowledge_index_failed"
+  "knowledge_index_failed",
+  // A PDF or DOCX with more pages than `knowledge.maxPagesPerDocument`, counted before its text
+  // is read.
+  "knowledge_file_too_many_pages",
+  // A built-in or Workflow processor returned output outside its contract.
+  "knowledge_processor_output_invalid",
+  // Conversion exceeded its page-aware deadline.
+  "knowledge_conversion_timeout"
 ];
 var KNOWLEDGE_DOCUMENT_WAIT_CODES = [
   // A usage limit of the instance or the workspace refuses the embedding calls. Indexing goes
@@ -486,7 +521,9 @@ var KNOWLEDGE_SOURCE_FAILURE_CODES = [
   // A fetch failed on every attempt.
   "knowledge_fetch_failed",
   // The Knowledge Base holds its document limit; the listing stopped discovering there.
-  "knowledge_source_limit_reached"
+  "knowledge_source_limit_reached",
+  "knowledge_item_invalid",
+  "knowledge_fetch_not_allowed"
 ];
 var KNOWLEDGE_SOURCE_ITEM_FAILURE_CODES = [
   ...KNOWLEDGE_SOURCE_FAILURE_CODES,
@@ -500,7 +537,7 @@ var KNOWLEDGE_SOURCE_ITEM_STATES = [
   "withdrawn"
 ];
 var KNOWLEDGE_SYNC_MODES = ["initial", "changes", "full"];
-var KNOWLEDGE_SYNC_RUN_STATES = ["running", "done", "failed"];
+var KNOWLEDGE_SYNC_RUN_STATES = ["running", "done", "failed", "superseded"];
 var KNOWLEDGE_SYNC_COUNTS = [
   "discovered",
   "added",
@@ -518,6 +555,7 @@ var DATABASE_RELATION_TYPES = [
   "foreign_table"
 ];
 var WORKFLOW_RUN_STATUSES = [
+  "continued",
   "queued",
   "running",
   "waiting",
@@ -544,6 +582,14 @@ var WORKFLOW_RESERVED_STEP_TYPES = [
 ];
 var WORKFLOW_TRIGGER_KINDS = ["manual", "schedule", "parent"];
 var NOTIFY_CHANNELS = ["inbox", "mail"];
+var WORKFLOW_STEP_SOURCE_KINDS = [
+  "connection",
+  "data_store",
+  "knowledge_base",
+  "workflow",
+  "mail_sender",
+  "other"
+];
 var PRINCIPAL_HOLDER_KINDS = [
   "user",
   "service_principal"
@@ -642,11 +688,19 @@ var WORKFLOW_STEP_RUN_STATUSES = [
   "cancelled"
 ];
 var WORKFLOW_ENDED_STATUSES = [
+  "continued",
   "done",
   "failed",
   "cancelled",
   "limit_reached"
 ];
+var MANAGED_FILE_STATUSES = ["available", "released", "deleted"];
+var WORKFLOW_KINDS = ["process", "data"];
+var WORKFLOW_DATASET_DOWNLOAD_FORMATS = ["jsonl", "csv"];
+var WORKSPACE_USE_ASSET_KINDS = ["knowledge_base", "connection"];
+var PUBLISHED_DATA_CONSUMER_KINDS = ["app", "workflow", "knowledge_base"];
+var SCHEDULED_START_STATES = ["active", "paused"];
+var AGENT_PREVIEW_SOURCES = ["draft", "live"];
 
 // src/schemas.ts
 import { z } from "zod";
@@ -806,12 +860,12 @@ var skillConfigObjectSchema = z.object({
   icon: z.string().min(1).optional()
 });
 var skillConfigSchema = skillConfigObjectSchema.superRefine((skill, context) => {
-  for (const key of SKILL_FRONTMATTER_FIELDS) {
-    if (skill.frontmatter && Object.hasOwn(skill.frontmatter, key)) {
+  for (const key2 of SKILL_FRONTMATTER_FIELDS) {
+    if (skill.frontmatter && Object.hasOwn(skill.frontmatter, key2)) {
       context.addIssue({
         code: "custom",
-        path: ["frontmatter", key],
-        message: `Skill frontmatter cannot hold '${key}': it is a field of the skill itself`
+        path: ["frontmatter", key2],
+        message: `Skill frontmatter cannot hold '${key2}': it is a field of the skill itself`
       });
     }
   }
@@ -844,7 +898,7 @@ var welcomeSubtitleSchema = z.union([
     message: "At least one localized value is required"
   })
 ]);
-var agentNameSchema = z.string().min(1).refine((name) => name !== "." && name !== "..", {
+var agentNameSchema = z.string().min(1).refine((name2) => name2 !== "." && name2 !== "..", {
   message: "Agent name must not be '.' or '..'"
 });
 var agentConfigSchema = z.object({
@@ -898,8 +952,8 @@ import yaml from "js-yaml";
 // src/yaml-data.ts
 import { JSON_SCHEMA, YAMLException, load } from "js-yaml";
 var YAML_DATA_MAX_VALUES = 1e5;
-function isStorableText(text) {
-  return !text.includes("\0") && !/\p{Surrogate}/u.test(text);
+function isStorableText(text2) {
+  return !text2.includes("\0") && !/\p{Surrogate}/u.test(text2);
 }
 function checkStorableTexts(value, maxValues) {
   const pending = [value];
@@ -911,15 +965,15 @@ function checkStorableTexts(value, maxValues) {
     } else if (Array.isArray(next)) {
       for (const entry of next) pending.push(entry);
     } else if (typeof next === "object" && next !== null) {
-      for (const [key, entry] of Object.entries(next)) {
-        if (!isStorableText(key)) return "unstorable";
+      for (const [key2, entry] of Object.entries(next)) {
+        if (!isStorableText(key2)) return "unstorable";
         pending.push(entry);
       }
     }
   }
   return "storable";
 }
-function readYamlData(text, file, options = {}) {
+function readYamlData(text2, file, options = {}) {
   const fail = (code, message, line, column) => ({
     ok: false,
     issue: {
@@ -931,7 +985,7 @@ function readYamlData(text, file, options = {}) {
   });
   let value;
   try {
-    value = load(text, { schema: JSON_SCHEMA, filename: file });
+    value = load(text2, { schema: JSON_SCHEMA, filename: file });
   } catch (error) {
     if (error instanceof YAMLException) {
       const markLine = error.mark?.line;
@@ -968,8 +1022,8 @@ var YamlDataError = class extends Error {
     this.issue = issue;
   }
 };
-function loadYamlData(text, file) {
-  const read = readYamlData(text, file);
+function loadYamlData(text2, file) {
+  const read = readYamlData(text2, file);
   if (!read.ok) throw new YamlDataError(read.issue);
   return read.value;
 }
@@ -1006,7 +1060,7 @@ function parseSkillMarkdown(contents, skillFile, skillPath) {
   }
   const content = (match[2] ?? "").trim();
   const { name: named, title, description, summary, starters, ...others } = frontmatter.data;
-  const name = named ?? deriveSkillName(skillPath);
+  const name2 = named ?? deriveSkillName(skillPath);
   const json = JSON.stringify(others);
   if (json.length > SKILL_FRONTMATTER_MAX_BYTES) {
     throw new SkillMarkdownError(
@@ -1017,8 +1071,8 @@ function parseSkillMarkdown(contents, skillFile, skillPath) {
   }
   const kept = JSON.parse(json);
   return {
-    name,
-    title: title ?? deriveSkillTitle(name, content),
+    name: name2,
+    title: title ?? deriveSkillTitle(name2, content),
     description,
     ...summary === void 0 ? {} : { summary },
     ...starters === void 0 ? {} : { starters },
@@ -1026,8 +1080,8 @@ function parseSkillMarkdown(contents, skillFile, skillPath) {
     ...Object.keys(others).length > 0 ? { frontmatter: kept } : {}
   };
 }
-function loadFrontmatter(text, skillFile) {
-  const read = readYamlData(text, skillFile, { refuseAliases: true });
+function loadFrontmatter(text2, skillFile) {
+  const read = readYamlData(text2, skillFile, { refuseAliases: true });
   if (read.ok) return read.value;
   const { issue } = read;
   if (issue.code === "yaml_alias") {
@@ -1054,7 +1108,7 @@ function loadFrontmatter(text, skillFile) {
     { issues: [{ message: issue.message, path: [], line, column }] }
   );
 }
-function deriveSkillTitle(name, content) {
+function deriveSkillTitle(name2, content) {
   let fence;
   for (const line of content.split(/\r?\n/u)) {
     const marker = /^\s{0,3}(`{3,}|~{3,})/u.exec(line)?.[1];
@@ -1065,8 +1119,8 @@ function deriveSkillTitle(name, content) {
     const heading = fence === void 0 ? /^ {0,3}#{1,6}\s+(.+?)(?:\s+#+)?\s*$/u.exec(line) : null;
     if (heading?.[1]) return heading[1];
   }
-  const words = name.replace(/[-_]+/gu, " ").trim();
-  return words === "" ? name : words.charAt(0).toUpperCase() + words.slice(1);
+  const words = name2.replace(/[-_]+/gu, " ").trim();
+  return words === "" ? name2 : words.charAt(0).toUpperCase() + words.slice(1);
 }
 function formatSkillMarkdown(skill) {
   const content = skill.content.trim();
@@ -1111,6 +1165,788 @@ function withoutExtension(filename) {
   const dot = filename.lastIndexOf(".");
   return dot > 0 ? filename.slice(0, dot) : filename;
 }
+
+// src/knowledge-write.ts
+import { z as z3 } from "zod";
+
+// src/operation-batch.ts
+import { z as z2 } from "zod";
+var workflowDatasetReferenceSchema = z2.strictObject({
+  $dataset: z2.string().min(1),
+  rowCount: z2.number().int().min(0),
+  // A view keeps the parent byte count as an upper bound.
+  bytes: z2.number().int().min(0),
+  /** Absolute offset in the parent; rowCount bounds the view. No rows are copied. */
+  offset: z2.number().int().nonnegative().optional()
+});
+var operationBatchFailureSchema = z2.strictObject({
+  item: z2.json(),
+  code: z2.string().min(1),
+  message: z2.string().min(1)
+});
+var operationBatchResultSchema = z2.strictObject({
+  done: z2.number().int().min(0),
+  failed: z2.number().int().min(0),
+  failures: workflowDatasetReferenceSchema
+});
+
+// src/knowledge-write.ts
+var id = z3.string().min(1).max(200);
+var count = z3.number().int().min(0);
+var hash = z3.string().regex(/^[a-f0-9]{64}$/u);
+var text = z3.string().max(KNOWLEDGE_FILE_MAX_BYTES).refine((value) => new TextEncoder().encode(value).byteLength <= KNOWLEDGE_FILE_MAX_BYTES, {
+  message: `Document text exceeds ${KNOWLEDGE_FILE_MAX_BYTES} bytes`
+});
+var knowledgeIngestFetchSchema = z3.strictObject({
+  connection: id,
+  operation: id,
+  input: z3.record(z3.string(), z3.json())
+});
+var ingestItemIdentity = z3.strictObject({
+  itemId: id,
+  version: id,
+  name: z3.string().min(1).max(1e3),
+  path: z3.string().startsWith("/").max(4e3).optional(),
+  originLink: z3.url({ protocol: /^https?$/u }).max(4e3).optional(),
+  metadata: z3.record(z3.string(), z3.json()).optional(),
+  text: z3.never().optional(),
+  fileId: z3.never().optional(),
+  fetch: z3.never().optional()
+});
+var knowledgeIngestItemSchema = z3.union(
+  [
+    ingestItemIdentity.extend({ text }),
+    ingestItemIdentity.extend({ fileId: id }),
+    ingestItemIdentity.extend({ fetch: knowledgeIngestFetchSchema })
+  ],
+  { error: "knowledge_item_invalid: Supply exactly one of text, fileId or fetch" }
+).superRefine((item, context) => {
+  if (item.fetch !== void 0)
+    context.addIssue({
+      code: "custom",
+      path: ["fetch"],
+      message: "not_supported_yet: fetch arrives with CONN-DL; supply text or fileId"
+    });
+});
+var knowledgeIngestInputSchema = z3.union([
+  z3.strictObject({ items: z3.array(knowledgeIngestItemSchema), complete: z3.boolean().optional() }),
+  z3.strictObject({ dataset: workflowDatasetReferenceSchema, complete: z3.boolean().optional() })
+]);
+var knowledgeIngestOutputSchema = operationBatchResultSchema.extend({
+  accepted: count,
+  withdrawn: count
+});
+var knowledgeWithdrawInputSchema = z3.strictObject({ itemIds: z3.array(id).min(1) });
+var knowledgeWithdrawOutputSchema = z3.strictObject({ withdrawn: count });
+var knowledgePendingInputSchema = z3.strictObject({
+  type: id.optional(),
+  since: z3.iso.datetime({ offset: true }).optional(),
+  limit: z3.number().int().positive()
+});
+var knowledgePendingRowSchema = z3.strictObject({
+  id,
+  type: id,
+  contentHash: hash,
+  pages: workflowDatasetReferenceSchema
+});
+var knowledgePendingOutputSchema = z3.strictObject({
+  documents: workflowDatasetReferenceSchema
+});
+var pageNumber = z3.number().int().positive();
+var range = z3.strictObject({ pageFrom: pageNumber, pageTo: pageNumber });
+var processorMetadataSchema = z3.strictObject({
+  documents: z3.array(range).min(1),
+  sections: z3.array(range.extend({ title: z3.string().min(1) })).optional(),
+  fields: z3.record(z3.string(), z3.json())
+});
+var knowledgeProcessorOutputSchema = processorMetadataSchema.extend({
+  // Count stays unbounded here: PROC-1/PROC-W must enforce the instance's
+  // knowledge.maxPagesPerDocument at runtime (KB-ISO-3a), not a new contract cap.
+  pages: z3.array(z3.strictObject({ page: pageNumber, text })).min(1)
+}).superRefine((output, context) => {
+  const pages = new Set(output.pages.map((page) => page.page));
+  if (output.pages.some(
+    (page, index) => index > 0 && page.page <= (output.pages[index - 1]?.page ?? 0)
+  )) {
+    context.addIssue({
+      code: "custom",
+      path: ["pages"],
+      message: "knowledge_processor_output_invalid: Pages must be ascending and unique"
+    });
+  }
+  const bytes = output.pages.reduce(
+    (size, page) => size + new TextEncoder().encode(page.text).byteLength,
+    0
+  );
+  if (bytes > KNOWLEDGE_FILE_MAX_BYTES)
+    context.addIssue({
+      code: "custom",
+      path: ["pages"],
+      message: "knowledge_processor_output_invalid: Document text exceeds the per-document limit"
+    });
+  for (const field of ["documents", "sections"]) {
+    output[field]?.forEach((entry, index) => {
+      if (entry.pageFrom > entry.pageTo || !pages.has(entry.pageFrom) || !pages.has(entry.pageTo)) {
+        context.addIssue({
+          code: "custom",
+          path: [field, index],
+          message: "knowledge_processor_output_invalid: Page range must be ordered and inside the document"
+        });
+      }
+    });
+  }
+});
+var knowledgePutProcessedInputSchema = z3.strictObject({
+  items: z3.union([
+    z3.array(
+      z3.strictObject({
+        documentId: id,
+        contentHash: hash,
+        workflowRevision: id,
+        // Mirror pending: page text lives outside step values and item dataset rows.
+        // PROC-W resolves the pages and validates the full processor output above.
+        output: processorMetadataSchema.extend({ pages: workflowDatasetReferenceSchema })
+      })
+    ),
+    workflowDatasetReferenceSchema
+  ])
+});
+var knowledgeFieldValueSchema = z3.json();
+var knowledgeExtractFieldsInputSchema = z3.strictObject({
+  documentId: id,
+  schema: z3.record(z3.string(), knowledgeFieldValueSchema)
+});
+var knowledgeExtractFieldsOutputSchema = z3.strictObject({
+  droppedFields: z3.number().int().nonnegative().optional(),
+  failedFields: z3.number().int().nonnegative().optional(),
+  path: z3.string(),
+  date: z3.iso.date().nullable(),
+  type: id,
+  fields: z3.record(
+    z3.string(),
+    z3.strictObject({ value: knowledgeFieldValueSchema, page: pageNumber, quote: z3.string().min(1) })
+  )
+});
+var knowledgeWorkflowSourceSchema = z3.strictObject({
+  id: z3.string().startsWith("workflow:"),
+  kind: z3.literal("workflow"),
+  workflowId: z3.string().regex(/^[a-z][a-z0-9_-]{0,62}$/u)
+}).refine((source) => source.id === `workflow:${source.workflowId}`, {
+  path: ["id"],
+  message: "A Workflow source id is workflow:<workflowId>"
+});
+var knowledgeWriteContracts = {
+  ingest: {
+    description: "Ingest items or a dataset into the calling data Workflow's source; complete promises a full pass, withdrawn only after the run succeeds.",
+    inputSchema: knowledgeIngestInputSchema,
+    outputSchema: knowledgeIngestOutputSchema,
+    effect: "changing",
+    right: "knowledge_base.write",
+    keyLevel: "write",
+    completion: "async",
+    batch: true
+  },
+  withdraw: {
+    description: "Withdraw item ids from the calling Workflow's source; removed from search immediately.",
+    inputSchema: knowledgeWithdrawInputSchema,
+    outputSchema: knowledgeWithdrawOutputSchema,
+    effect: "changing",
+    right: "knowledge_base.write",
+    keyLevel: "write"
+  },
+  pending: {
+    description: "Pull pending documents by type and time as a dataset; page text is another dataset reference.",
+    inputSchema: knowledgePendingInputSchema,
+    outputSchema: knowledgePendingOutputSchema,
+    rowSchema: knowledgePendingRowSchema,
+    effect: "reading",
+    right: "knowledge_base.read",
+    keyLevel: "read",
+    dataset: true
+  },
+  put_processed: {
+    description: "Write processor output by document, content hash and Workflow revision, with pages as a dataset reference like pending; the platform validates, chunks and indexes it, with per-item outcomes.",
+    inputSchema: knowledgePutProcessedInputSchema,
+    outputSchema: operationBatchResultSchema,
+    effect: "changing",
+    right: "knowledge_base.write",
+    keyLevel: "write",
+    batch: true
+  },
+  extract_fields: {
+    description: "Extract fields by schema through the approved model binding within the Knowledge Base budget; each value carries page and quote evidence.",
+    inputSchema: knowledgeExtractFieldsInputSchema,
+    outputSchema: knowledgeExtractFieldsOutputSchema,
+    effect: "reading",
+    right: "knowledge_base.read",
+    keyLevel: "read"
+  }
+};
+var knowledgeRecordsRefusalSchema = z3.never({
+  error: "'records' belongs in store.yaml. A data Workflow proposes fields into the Data Store's records mechanism."
+}).optional();
+
+// src/knowledge-sources.ts
+import { z as z4 } from "zod";
+var sourceIdSchema = z4.union([
+  z4.string().regex(/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/u).max(63),
+  knowledgeWorkflowSourceSchema.shape.id.regex(/^workflow:[a-z][a-z0-9_-]{0,62}$/u)
+]);
+var countSchema = z4.number().int().min(0);
+var countsSchema = z4.strictObject({
+  discovered: countSchema,
+  added: countSchema,
+  changed: countSchema,
+  moved: countSchema,
+  withdrawn: countSchema,
+  failed: countSchema,
+  skipped: countSchema
+});
+var knowledgeSyncInputSchema = z4.strictObject({
+  /** The `id` of the source in the definition. */
+  source: sourceIdSchema,
+  /** `changes` unless `full`. The initial import is started by publish, not by this call. */
+  mode: z4.enum(["changes", "full"]).optional()
+});
+var knowledgeSyncResultSchema = z4.strictObject({
+  syncRunId: z4.string(),
+  source: z4.string(),
+  mode: z4.enum(KNOWLEDGE_SYNC_MODES),
+  /** Why a run is of another mode than asked, such as a cursor the source refused. */
+  reason: z4.enum(["cursor_expired"]).optional(),
+  state: z4.enum(KNOWLEDGE_SYNC_RUN_STATES),
+  counts: countsSchema,
+  bytesFetched: z4.number().int().min(0),
+  /** Why the whole sync failed, for a run in state `failed`. */
+  failureCode: z4.enum(KNOWLEDGE_SOURCE_FAILURE_CODES).optional(),
+  startedAt: z4.string(),
+  endedAt: z4.string().optional()
+});
+var KNOWLEDGE_SOURCE_ITEM_SHOWN_STATES = [
+  "discovered",
+  "fetched",
+  "indexed",
+  "failed",
+  "withdrawn"
+];
+var itemFailureCodeSchema = z4.union([
+  z4.enum(KNOWLEDGE_SOURCE_ITEM_FAILURE_CODES),
+  z4.enum(KNOWLEDGE_DOCUMENT_FAILURE_CODES)
+]);
+var sourceStatusSchema = z4.strictObject({
+  id: z4.string(),
+  /** The name of the Connection it reads through. */
+  connection: z4.string(),
+  kind: z4.literal("connector").optional(),
+  /** Items by the state the page shows. */
+  items: z4.strictObject({
+    discovered: countSchema,
+    fetched: countSchema,
+    indexed: countSchema,
+    failed: countSchema,
+    withdrawn: countSchema
+  }),
+  /** Failed items per code. */
+  failures: z4.array(z4.strictObject({ code: itemFailureCodeSchema, count: countSchema })),
+  /** The sync that runs now, with its rate in items per minute and its estimated end. */
+  running: z4.strictObject({
+    syncRunId: z4.string(),
+    mode: z4.enum(KNOWLEDGE_SYNC_MODES),
+    startedAt: z4.string(),
+    itemsPerMinute: z4.number().min(0).optional(),
+    estimatedEndAt: z4.string().optional()
+  }).optional(),
+  /** The last sync that ended. */
+  last: knowledgeSyncResultSchema.optional(),
+  /** "Letzte Änderung verarbeitet". */
+  lastChangeAt: z4.string().optional(),
+  /** "Älteste offene Änderung". */
+  oldestOpenChangeAt: z4.string().optional()
+});
+var knowledgeSourcesOutputSchema = z4.strictObject({
+  sources: z4.array(
+    z4.union([
+      sourceStatusSchema,
+      knowledgeWorkflowSourceSchema.safeExtend(
+        sourceStatusSchema.omit({ id: true, connection: true, kind: true }).shape
+      )
+    ])
+  )
+});
+var knowledgeSourceItemsInputSchema = z4.strictObject({
+  source: sourceIdSchema,
+  state: z4.enum(KNOWLEDGE_SOURCE_ITEM_SHOWN_STATES).optional(),
+  failureCode: itemFailureCodeSchema.optional(),
+  /** Items per page: 50 by default, at most 200. */
+  limit: z4.coerce.number().int().min(1).max(200).optional(),
+  cursor: z4.string().min(1).max(1e3).optional()
+});
+var knowledgeSourceItemsOutputSchema = z4.strictObject({
+  /** Newest change first. */
+  items: z4.array(
+    z4.strictObject({
+      /** The row in `source_items`: what `retry` and `locate` name. */
+      id: z4.string(),
+      /** The id of the item at the source. */
+      itemId: z4.string(),
+      name: z4.string(),
+      path: z4.string(),
+      state: z4.enum(KNOWLEDGE_SOURCE_ITEM_SHOWN_STATES),
+      failureCode: itemFailureCodeSchema.optional(),
+      documentId: z4.string().optional(),
+      originLink: z4.string().optional(),
+      changedAt: z4.string()
+    })
+  ),
+  nextCursor: z4.string().optional()
+});
+var RETRY_MAX = 100;
+var knowledgeRetryInputSchema = z4.union([
+  z4.strictObject({ documentIds: z4.array(z4.string().min(1).max(200)).min(1).max(RETRY_MAX) }),
+  z4.strictObject({
+    source: sourceIdSchema,
+    sourceItemIds: z4.array(z4.string().min(1).max(200)).min(1).max(RETRY_MAX)
+  }),
+  z4.strictObject({ source: sourceIdSchema, failureCode: itemFailureCodeSchema }),
+  z4.strictObject({ source: sourceIdSchema, all: z4.literal(true) })
+]);
+var knowledgeRetryOutputSchema = z4.strictObject({
+  /** For a retry by document ids: each named document, with its state after the retry. */
+  documents: z4.array(z4.strictObject({ id: z4.string(), state: z4.enum(KNOWLEDGE_DOCUMENT_STATES) })).optional(),
+  /** How many contents or items were queued again. */
+  queued: z4.number().int()
+});
+var knowledgeLocateInputSchema = z4.strictObject({
+  /** The row in `source_items`. */
+  sourceItemId: z4.string().min(1).max(200)
+});
+var knowledgeLocateOutputSchema = z4.strictObject({
+  sourceItemId: z4.string(),
+  source: z4.string(),
+  itemId: z4.string(),
+  state: z4.enum(KNOWLEDGE_SOURCE_ITEM_SHOWN_STATES),
+  discoveredAt: z4.string(),
+  fetchedAt: z4.string().optional(),
+  withdrawnAt: z4.string().optional(),
+  purgedAt: z4.string().optional()
+});
+
+// src/workflow-datasets.ts
+var WORKFLOW_DATASET_STATES = ["writing", "complete", "deleted"];
+
+// src/operation-paging.ts
+import { z as z5 } from "zod";
+var operationPagingSchema = z5.discriminatedUnion("by", [
+  z5.strictObject({
+    by: z5.enum(["page", "offset"]),
+    param: z5.string().min(1),
+    sizeParam: z5.string().min(1),
+    size: z5.number().int().min(1),
+    start: z5.number().int().min(0).optional()
+  }),
+  z5.strictObject({
+    by: z5.enum(["cursor", "next_link"]),
+    param: z5.string().min(1),
+    cursor: z5.string().min(1)
+  })
+]);
+
+// src/workflow-data-flows.ts
+import { z as z6 } from "zod";
+var workflowDataFlowsSchema = z6.object({
+  fills: z6.array(z6.object({ id: z6.string(), name: z6.string(), title: z6.string() })),
+  processes: z6.array(z6.object({ id: z6.string(), name: z6.string(), title: z6.string() })),
+  hidden: z6.object({ fills: z6.number().int().min(0), processes: z6.number().int().min(0) }),
+  truncated: z6.boolean()
+});
+
+// src/data-store-records.ts
+import { z as z7 } from "zod";
+var RECORDS_PROPOSE_MAX_ITEMS_PER_CALL = 1e3;
+var RECORDS_PROPOSE_MAX_FIELDS_PER_ITEM = 1e3;
+var RECORDS_FLAGGED_MAX_ITEMS_PER_PAGE = 1e4;
+var name = z7.string().min(1);
+var id2 = z7.string().min(1).max(200);
+var key = z7.union([z7.string().min(1), z7.number(), z7.boolean()]);
+var dataStoreRecordsRuleSchema = z7.strictObject({
+  table: name,
+  key: z7.union([
+    z7.strictObject({ column: name, fromPath: z7.string().startsWith("/").min(1) }),
+    z7.strictObject({ column: name, fromField: name })
+  ]),
+  precedence: z7.array(name).default([]),
+  review: z7.strictObject({ always: z7.array(name).default([]) }).default({ always: [] }),
+  retainWithoutSource: z7.boolean().default(false)
+}).superRefine((rule, context) => {
+  if ("fromPath" in rule.key) {
+    const placeholders = rule.key.fromPath.match(/\{[^{}]*\}/gu);
+    if (placeholders?.length !== 1 || placeholders[0] !== `{${rule.key.column}}`) {
+      context.addIssue({
+        code: "custom",
+        path: ["key", "fromPath"],
+        message: "fromPath must contain exactly one placeholder naming the key column"
+      });
+    }
+  }
+});
+var recordEvidenceResultSchema = z7.discriminatedUnion("status", [
+  z7.strictObject({ status: z7.literal("passed") }),
+  z7.strictObject({
+    status: z7.literal("failed"),
+    reason: z7.enum(["page_not_found", "quote_not_found", "value_not_parsed"])
+  })
+]);
+var RECORD_FIELD_STATES = ["extracted", "confirmed", "corrected", "conflict"];
+var RECORD_FIELD_FAILURE_CODES = ["record_field_unknown"];
+var fieldSchema = knowledgeExtractFieldsOutputSchema.shape.fields.valueType.extend({ name });
+var dataStoreRecordProposalItemSchema = z7.strictObject({
+  // Document ids are scoped by their Knowledge Base. Both ids travel with every citation.
+  knowledgeBaseId: id2,
+  documentId: id2,
+  kind: name,
+  documentDate: z7.iso.date().nullable(),
+  path: z7.string().startsWith("/").optional(),
+  fields: z7.array(fieldSchema).min(1).max(
+    RECORDS_PROPOSE_MAX_FIELDS_PER_ITEM,
+    "At most 1000 fields per item (RECORDS_PROPOSE_MAX_FIELDS_PER_ITEM); split larger proposals into batches"
+  )
+});
+var dataStoreRecordsProposeInputSchema = z7.strictObject({
+  table: name,
+  items: z7.array(dataStoreRecordProposalItemSchema).max(
+    RECORDS_PROPOSE_MAX_ITEMS_PER_CALL,
+    "At most 1000 items per call (RECORDS_PROPOSE_MAX_ITEMS_PER_CALL); send another batch"
+  )
+});
+var decisionSchema = z7.strictObject({
+  table: name,
+  key,
+  field: name,
+  documentId: id2.optional(),
+  knowledgeBaseId: id2.optional()
+});
+var dataStoreRecordsDecideInputSchema = z7.discriminatedUnion("action", [
+  decisionSchema.extend({ action: z7.literal("confirm") }),
+  decisionSchema.extend({ action: z7.literal("correct"), value: z7.json() }),
+  decisionSchema.extend({ action: z7.literal("assign"), documentId: id2, knowledgeBaseId: id2 })
+]).refine(
+  (decision) => decision.documentId === void 0 === (decision.knowledgeBaseId === void 0),
+  {
+    path: ["documentId"],
+    message: "A citation needs both knowledgeBaseId and documentId"
+  }
+);
+var dataStoreRecordsDecideOutputSchema = z7.strictObject({ decided: z7.literal(true) });
+var dataStoreRecordsFlaggedInputSchema = z7.strictObject({
+  table: name.optional(),
+  cursor: z7.string().min(1).optional(),
+  limit: z7.number().int().positive().max(
+    RECORDS_FLAGGED_MAX_ITEMS_PER_PAGE,
+    "At most 10000 items per page (RECORDS_FLAGGED_MAX_ITEMS_PER_PAGE); follow nextCursor"
+  )
+});
+var dataStoreRecordFieldSchema = fieldSchema.extend({
+  table: name,
+  // Unresolved keys go to review, without writing a customer row.
+  key: key.nullable(),
+  knowledgeBaseId: id2,
+  documentId: id2,
+  kind: name,
+  documentDate: z7.iso.date().nullable(),
+  extractedAt: z7.iso.datetime({ offset: true }),
+  evidence: recordEvidenceResultSchema,
+  state: z7.enum(RECORD_FIELD_STATES),
+  decidedBy: id2.nullable(),
+  decidedAt: z7.iso.datetime({ offset: true }).nullable()
+});
+var dataStoreRecordsFlaggedOutputSchema = z7.strictObject({
+  // A citation is shown only after checking access to its Knowledge Base, even for a
+  // holder of data_store.records. Values/quotes never enter jobs, runs or audit metadata.
+  items: z7.array(
+    dataStoreRecordFieldSchema.extend({
+      reason: z7.enum(["conflict", "not_evidenced", "confirmation_required", "key_unresolved"])
+    })
+  ).max(RECORDS_FLAGGED_MAX_ITEMS_PER_PAGE),
+  nextCursor: z7.string().optional()
+});
+var scalarSchemas = {
+  text: z7.string(),
+  integer: z7.number().int(),
+  number: z7.number(),
+  boolean: z7.boolean(),
+  date: z7.iso.date(),
+  timestamp: z7.iso.datetime({ offset: true })
+};
+function compatible(column, value) {
+  if (column.generated || column.type === "other") return false;
+  if (value === null) return column.nullable;
+  for (const [type, schema] of Object.entries(scalarSchemas)) {
+    if (column.type === type) return schema.safeParse(value).success;
+    if (column.type === `${type}[]`) return z7.array(schema.nullable()).safeParse(value).success;
+  }
+  return false;
+}
+function proposalItemSchemaFor(columns) {
+  const byName = new Map(columns.map((column) => [column.name, column]));
+  return dataStoreRecordProposalItemSchema.superRefine((item, context) => {
+    const seen = /* @__PURE__ */ new Set();
+    item.fields.forEach((field, index) => {
+      const column = byName.get(field.name);
+      if (!column || !compatible(column, field.value) || seen.has(field.name)) {
+        context.addIssue({
+          code: "custom",
+          path: ["fields", index],
+          message: `record_field_unknown: Field '${field.name}' has no writable column of a compatible type, or occurs twice`
+        });
+      }
+      seen.add(field.name);
+    });
+  });
+}
+var dataStoreRecordsContracts = {
+  propose: {
+    description: "Propose extracted fields with Knowledge Base/document/page/quote evidence. Validate each whole item against the published table before writing; failures are per item. Send at most 1000 items per call and 1000 fields per item; split larger work into batches. Merge by evidence precedence, then document date; unresolved keys and evidence go to review.",
+    inputSchema: dataStoreRecordsProposeInputSchema,
+    outputSchema: operationBatchResultSchema,
+    itemSchemaFor: proposalItemSchemaFor,
+    effect: "changing",
+    right: "data_store.records",
+    keyLevel: "write",
+    batch: true
+  },
+  decide: {
+    description: "Confirm or correct a field against its evidence, or assign a document to an object key. Decisions are pinned; audit table/field/action/actor only, never the value.",
+    inputSchema: dataStoreRecordsDecideInputSchema,
+    outputSchema: dataStoreRecordsDecideOutputSchema,
+    effect: "changing",
+    right: "data_store.records",
+    keyLevel: "write"
+  },
+  flagged: {
+    description: "Page through fields needing review, up to 10000 per call; pass nextCursor as cursor for the next page. Check Knowledge Base access before showing any document citation; the store right alone does not grant access to source documents.",
+    inputSchema: dataStoreRecordsFlaggedInputSchema,
+    outputSchema: dataStoreRecordsFlaggedOutputSchema,
+    effect: "reading",
+    right: "data_store.records",
+    keyLevel: "read"
+  }
+};
+
+// src/usage-limits.ts
+var MODEL_USAGE_LIMIT_PERIODS = ["day", "month"];
+var MODEL_USAGE_LIMIT_METRICS = ["modelCallCount", "tokens", "costMicros"];
+var MODEL_USAGE_LIMIT_SCOPES = ["instance", "user", "system"];
+
+// src/workflow-text.ts
+var WORKFLOW_TEXT_FORMAT_MARKDOWN = "markdown";
+var WORKFLOW_TEXT_MAX_PARTS = 100;
+var WORKFLOW_MARKDOWN_MAX_ROWS = 100;
+var WORKFLOW_MARKDOWN_MAX_COLUMNS = 8;
+
+// src/mail-send.ts
+import { z as z8 } from "zod";
+var MAIL_SEND_OPERATION = "mail.send";
+var MAIL_SENDER_RESOURCE_KIND = "mail_sender";
+var MAIL_SENDER_USE_ACTION = "mail_sender.use";
+var MAIL_SENDER_SYSTEM = "system";
+var MAIL_SENDER_CONNECTION_PREFIX = "connection.";
+var MAIL_SENDER_SYSTEM_ICON = "system-mail";
+var MAIL_WORKFLOW_MESSAGE_TEMPLATE = "workflow-message";
+var MAIL_SEND_MAX_ADDRESSES = 50;
+var MAIL_SUBJECT_MAX_LENGTH = 200;
+var MAIL_BODY_MAX_BYTES = 64 * 1024;
+var MAIL_SENDER_NAME_MAX_LENGTH = 80;
+var MAIL_ADDRESS_MAX_LENGTH = 254;
+var MAIL_OUTBOUND_DEFAULT_LIMITS = {
+  perWorkflowPerHour: 200,
+  perInstancePerDay: 1e3
+};
+var MAIL_OUTBOUND_FOOTER_MAX_LENGTH = 2e3;
+var MAIL_AUDIT_MAX_DOMAINS = 10;
+var MAIL_ATTACHMENTS_MAX_FILES = 10;
+var MAIL_ATTACHMENTS_MAX_BYTES = 10 * 1024 * 1024;
+var MAIL_SEND_ERROR_CODES = {
+  recipientNotAllowed: "recipient_not_allowed",
+  noRecipient: "no_recipient",
+  mailRejected: "mail_rejected",
+  workspaceNotAllowed: "workspace_not_allowed"
+};
+var MAIL_SEND_REFUSAL_REASONS = [
+  MAIL_SEND_ERROR_CODES.recipientNotAllowed,
+  MAIL_SEND_ERROR_CODES.noRecipient,
+  MAIL_SEND_ERROR_CODES.mailRejected,
+  MAIL_SEND_ERROR_CODES.workspaceNotAllowed
+];
+var mailSendRefusalDetailsSchema = z8.discriminatedUnion("reason", [
+  z8.strictObject({
+    reason: z8.literal(MAIL_SEND_ERROR_CODES.recipientNotAllowed),
+    domain: z8.string().min(1).max(MAIL_ADDRESS_MAX_LENGTH)
+  }),
+  z8.strictObject({ reason: z8.literal(MAIL_SEND_ERROR_CODES.noRecipient) }),
+  z8.strictObject({ reason: z8.literal(MAIL_SEND_ERROR_CODES.workspaceNotAllowed) }),
+  z8.strictObject({
+    reason: z8.literal(MAIL_SEND_ERROR_CODES.mailRejected),
+    providerCode: z8.string().min(1).max(100).optional()
+  })
+]);
+var MAIL_RECIPIENT_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$/u;
+var principalId = z8.string().regex(MAIL_RECIPIENT_ID_PATTERN);
+var ONE_LINE_PATTERN = /^[^\u0000-\u001f\u007f\u2028\u2029]*$/u;
+var mailAddressSchema = z8.email().max(MAIL_ADDRESS_MAX_LENGTH);
+var MAIL_RECIPIENT_DOMAIN_PATTERN = /^(\*\.)?(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+(?:[a-z]{2,63}|xn--[a-z0-9-]{1,59})$/u;
+var MAIL_RECIPIENT_DOMAINS_ANY = "*";
+var mailRecipientDomainSchema = z8.string().max(MAIL_ADDRESS_MAX_LENGTH).refine(
+  (domain) => domain === MAIL_RECIPIENT_DOMAINS_ANY || MAIL_RECIPIENT_DOMAIN_PATTERN.test(domain),
+  { message: "A recipient domain is lowercase, such as kanzlei.de or *.kanzlei.de, or * alone" }
+);
+var mailSenderIdSchema = z8.union([
+  z8.literal(MAIL_SENDER_SYSTEM),
+  z8.templateLiteral([MAIL_SENDER_CONNECTION_PREFIX, z8.string().regex(CONNECTION_NAME_PATTERN)])
+]).superRefine((sender, context) => {
+  if (sender !== MAIL_SENDER_SYSTEM)
+    context.addIssue({
+      code: "custom",
+      message: "not_supported_yet: a Connection sender arrives with MAIL-M365S; send as system"
+    });
+});
+var mailRecipientSchema = z8.union([
+  z8.strictObject({ address: mailAddressSchema }),
+  z8.strictObject({ user: principalId }),
+  z8.strictObject({ workspace: principalId })
+]);
+var recipientEntries = z8.array(
+  z8.union([mailAddressSchema, mailRecipientSchema, z8.looseObject({ email: mailAddressSchema })])
+).max(MAIL_SEND_MAX_ADDRESSES);
+var mailRecipientListSchema = z8.union([mailAddressSchema, recipientEntries.min(1)]);
+var mailCopyRecipientListSchema = z8.union([mailAddressSchema, recipientEntries]);
+var mailReplyToSchema = z8.union([
+  mailAddressSchema,
+  z8.strictObject({ address: mailAddressSchema }),
+  z8.strictObject({ user: principalId })
+]);
+var mailSubjectSchema = z8.string().min(1).max(MAIL_SUBJECT_MAX_LENGTH).regex(ONE_LINE_PATTERN, { message: "input_invalid: a subject is one line" }).refine((subject) => subject.trim().length > 0, { message: "input_invalid: a subject has text" });
+var mailBodySchema = z8.string().max(MAIL_BODY_MAX_BYTES).refine((body) => new TextEncoder().encode(body).byteLength <= MAIL_BODY_MAX_BYTES, {
+  message: `input_invalid: the body exceeds ${MAIL_BODY_MAX_BYTES} bytes`
+}).meta({ format: WORKFLOW_TEXT_FORMAT_MARKDOWN });
+var mailSenderNameSchema = z8.string().min(1).max(MAIL_SENDER_NAME_MAX_LENGTH).regex(ONE_LINE_PATTERN, { message: "input_invalid: a sender name is one line" }).refine((name2) => !name2.includes("@"), {
+  message: "input_invalid: a sender name holds no @"
+});
+var mailSendInputSchema = z8.strictObject({
+  sender: mailSenderIdSchema.default(MAIL_SENDER_SYSTEM),
+  to: mailRecipientListSchema,
+  cc: mailCopyRecipientListSchema.optional(),
+  bcc: mailCopyRecipientListSchema.optional(),
+  subject: mailSubjectSchema,
+  body: mailBodySchema,
+  senderName: mailSenderNameSchema.optional(),
+  replyTo: mailReplyToSchema.optional(),
+  /** The language of the frame around the body; the instance's default unless set. */
+  locale: z8.enum(localeCodes).optional()
+});
+var count2 = z8.number().int().min(0);
+var recipientCounts = z8.strictObject({ to: count2, cc: count2, bcc: count2 });
+var mailSendOutputSchema = z8.strictObject({
+  sentAt: z8.iso.datetime({ offset: true }),
+  messageId: z8.string().min(1).max(256).optional(),
+  recipients: recipientCounts,
+  skipped: count2,
+  test: z8.literal(true).optional()
+});
+var mailPreviewRecipientSchema = z8.strictObject({
+  kind: z8.enum(["person", "address"]),
+  label: z8.string().min(1).max(MAIL_ADDRESS_MAX_LENGTH)
+});
+var mailSendPreviewSchema = z8.strictObject({
+  from: z8.strictObject({ name: z8.string().min(1), address: mailAddressSchema }),
+  replyTo: mailAddressSchema.optional(),
+  to: z8.array(mailPreviewRecipientSchema),
+  cc: z8.array(mailPreviewRecipientSchema),
+  bcc: z8.array(mailPreviewRecipientSchema),
+  skipped: count2,
+  subject: z8.string(),
+  html: z8.string(),
+  text: z8.string()
+});
+var mailSendSimulatedOutputSchema = z8.strictObject({
+  simulated: z8.literal(true),
+  preview: mailSendPreviewSchema
+});
+var workflowMessageMailParamsSchema = z8.strictObject({
+  subject: mailSubjectSchema,
+  markdown: mailBodySchema,
+  sentBy: z8.discriminatedUnion("kind", [
+    z8.strictObject({ kind: z8.literal("workflow"), workflowName: z8.string().min(1).max(200) }),
+    z8.strictObject({ kind: z8.literal("agent"), onBehalfOf: z8.string().min(1).max(200) })
+  ]),
+  test: z8.strictObject({
+    intendedRecipients: z8.strictObject({
+      to: z8.array(mailPreviewRecipientSchema),
+      cc: z8.array(mailPreviewRecipientSchema),
+      bcc: z8.array(mailPreviewRecipientSchema)
+    })
+  }).optional()
+});
+var workflowMailSenderFactSchema = z8.strictObject({
+  sender: z8.string().min(1),
+  title: z8.string().min(1),
+  icon: z8.string().min(1),
+  address: mailAddressSchema,
+  recipientDomains: z8.array(mailRecipientDomainSchema)
+});
+var mailSendContract = {
+  name: MAIL_SEND_OPERATION,
+  description: "Send one e-mail as a sender of the instance (system unless set). Recipients are addresses, people of the instance and workspaces; an address outside the instance's recipient domains is refused. The body is Markdown in the instance's frame. A test run previews the mail and sends nothing.",
+  inputSchema: mailSendInputSchema,
+  outputSchema: mailSendOutputSchema,
+  simulatedOutputSchema: mailSendSimulatedOutputSchema,
+  effect: "changing",
+  changeClass: "outward",
+  right: MAIL_SENDER_USE_ACTION,
+  resourceKind: MAIL_SENDER_RESOURCE_KIND,
+  events: { after: "mail.sent", refused: "mail.refused" },
+  errorCodes: MAIL_SEND_ERROR_CODES
+};
+
+// src/data-scope.ts
+import { z as z9 } from "zod";
+var dataScopeNameSchema = z9.string().regex(/^[a-z][a-z0-9_]{0,62}$/u);
+var dataScopesSchema = z9.record(
+  dataScopeNameSchema,
+  z9.strictObject({
+    label: z9.string().trim().min(1).max(120),
+    valueType: z9.literal("text")
+  })
+).refine(
+  (dimensions) => Object.keys(dimensions).length <= 1,
+  "One data scope dimension is supported"
+);
+var scopeAssignmentInputSchema = z9.strictObject({
+  dimension: dataScopeNameSchema,
+  holderKind: z9.enum(["user", "group", "service_principal"]),
+  holderId: z9.string().min(1).max(200).refine((value) => !value.includes("\0"), "NUL is not allowed"),
+  effect: z9.enum(GRANT_EFFECTS),
+  values: z9.union([
+    z9.literal("all"),
+    z9.array(
+      z9.string().min(1).max(200).refine((value) => !value.includes("\0"), "NUL is not allowed")
+    ).max(1e4)
+  ])
+});
+var identifier = z9.string().regex(/^[a-z_][a-z0-9_]{0,62}$/u);
+var scopedTablesSchema = z9.record(
+  identifier,
+  z9.strictObject({
+    scope: z9.record(dataScopeNameSchema, identifier).refine((scope) => Object.keys(scope).length === 1, "A scoped table names one dimension")
+  })
+);
+
+// src/feedback-values.ts
+var FEEDBACK_TEXT_MAX_LENGTH = 4e3;
+var FEEDBACK_SUMMARY_MAX_LENGTH = 1e3;
+var FEEDBACK_CATEGORY_MAX_LENGTH = 60;
+var FEEDBACK_NOTE_MAX_LENGTH = 2e3;
+var FEEDBACK_SUBJECT_KINDS = ["message"];
+var FEEDBACK_STATES = ["new", "handled"];
 export {
   ACCESS_SOURCES,
   ACTIONS,
@@ -1118,6 +1954,7 @@ export {
   ADMINISTERED_USER_STATUSES,
   AGENT_AVAILABILITY_MODES,
   AGENT_EDITABLE_FIELDS,
+  AGENT_PREVIEW_SOURCES,
   AGENT_RUN_FAILURE_CATEGORIES,
   AGENT_RUN_STATUSES,
   AGENT_STARTERS_MAX,
@@ -1127,12 +1964,14 @@ export {
   APPROVAL_EXECUTIONS,
   APPROVAL_REQUEST_STATUSES,
   APP_ACTION_CALL_STATUSES,
+  APP_AUDIENCES,
   APP_ERROR_CODES,
   APP_ERROR_STATUS_CODES,
   APP_MODES,
   ARTIFACT_PREVIEW_IMAGE_FORMATS,
   ARTIFACT_PREVIEW_IMAGE_MIME_TYPES,
   ARTIFACT_PREVIEW_STATUSES,
+  ASSET_ACCESS_VERBS,
   ASSET_LIFECYCLES,
   ASSET_NAME_REFUSAL_REASONS,
   ASSET_OWNER_KINDS,
@@ -1179,6 +2018,12 @@ export {
   ENDED_AGENT_RUN_STATUSES,
   ENDED_APPROVAL_EXECUTIONS,
   FAILED_JOB_STATUSES,
+  FEEDBACK_CATEGORY_MAX_LENGTH,
+  FEEDBACK_NOTE_MAX_LENGTH,
+  FEEDBACK_STATES,
+  FEEDBACK_SUBJECT_KINDS,
+  FEEDBACK_SUMMARY_MAX_LENGTH,
+  FEEDBACK_TEXT_MAX_LENGTH,
   FIRST_PARTY_AUTH_SCOPES,
   FOLLOW_UP_MODES,
   FOLLOW_UP_STATUSES,
@@ -1198,23 +2043,48 @@ export {
   KNOWLEDGE_DOCUMENT_FAILURE_CODES,
   KNOWLEDGE_DOCUMENT_STATES,
   KNOWLEDGE_DOCUMENT_WAIT_CODES,
+  KNOWLEDGE_FILE_MAX_BYTES,
   KNOWLEDGE_SEARCH_SIGNALS,
   KNOWLEDGE_SOURCE_FAILURE_CODES,
   KNOWLEDGE_SOURCE_ITEM_FAILURE_CODES,
+  KNOWLEDGE_SOURCE_ITEM_SHOWN_STATES,
   KNOWLEDGE_SOURCE_ITEM_STATES,
   KNOWLEDGE_SYNC_COUNTS,
   KNOWLEDGE_SYNC_MODES,
   KNOWLEDGE_SYNC_RUN_STATES,
   LISTED_DATA_STORE_STATUSES,
   LIVE_JOB_STATUSES,
+  MAIL_ADDRESS_MAX_LENGTH,
+  MAIL_ATTACHMENTS_MAX_BYTES,
+  MAIL_ATTACHMENTS_MAX_FILES,
+  MAIL_AUDIT_MAX_DOMAINS,
+  MAIL_BODY_MAX_BYTES,
+  MAIL_OUTBOUND_DEFAULT_LIMITS,
+  MAIL_OUTBOUND_FOOTER_MAX_LENGTH,
+  MAIL_RECIPIENT_DOMAINS_ANY,
+  MAIL_RECIPIENT_DOMAIN_PATTERN,
+  MAIL_RECIPIENT_ID_PATTERN,
+  MAIL_SENDER_CONNECTION_PREFIX,
+  MAIL_SENDER_NAME_MAX_LENGTH,
+  MAIL_SENDER_RESOURCE_KIND,
+  MAIL_SENDER_SYSTEM,
+  MAIL_SENDER_SYSTEM_ICON,
+  MAIL_SENDER_USE_ACTION,
+  MAIL_SEND_ERROR_CODES,
+  MAIL_SEND_MAX_ADDRESSES,
+  MAIL_SEND_OPERATION,
+  MAIL_SEND_REFUSAL_REASONS,
+  MAIL_SUBJECT_MAX_LENGTH,
+  MAIL_WORKFLOW_MESSAGE_TEMPLATE,
+  MANAGED_FILE_STATUSES,
   MESSAGE_FINISH_STATUSES,
   MODEL_PROVIDER_AUTH_MODES,
   MODEL_USAGE_EVENT_STATUSES,
+  MODEL_USAGE_LIMIT_METRICS,
+  MODEL_USAGE_LIMIT_PERIODS,
+  MODEL_USAGE_LIMIT_SCOPES,
   MODEL_USAGE_SOURCES,
   MODEL_USAGE_TIERS,
-  NAMESPACE_PREFIX_MAX_LENGTH,
-  NAMESPACE_PREFIX_MIN_LENGTH,
-  NAMESPACE_PREFIX_PATTERN,
   NOTIFY_CHANNELS,
   OPENAI_COMPATIBLE_APIS,
   OPERATIONS_AUDIENCES,
@@ -1231,8 +2101,18 @@ export {
   PROVIDER_CHECK_ERROR_CLASSES,
   PROVIDER_PORTS,
   PROVIDER_REGIONS,
+  PUBLISHED_DATA_CONSUMER_KINDS,
   READING_POLICY_VALUES,
   REASONING_EFFORTS,
+  RECORDS_FLAGGED_MAX_ITEMS_PER_PAGE,
+  RECORDS_PROPOSE_MAX_FIELDS_PER_ITEM,
+  RECORDS_PROPOSE_MAX_ITEMS_PER_CALL,
+  RECORD_FIELD_FAILURE_CODES,
+  RECORD_FIELD_STATES,
+  ROLE_GRANT_SCOPE_KINDS,
+  ROLE_PENDING_CHANGES,
+  ROLE_PENDING_DECISIONS,
+  SCHEDULED_START_STATES,
   SERVICE_PRINCIPAL_PERMISSIONS,
   SERVICE_PRINCIPAL_STATUSES,
   SKILL_CHANGE_TYPES,
@@ -1263,14 +2143,26 @@ export {
   USER_STATUSES,
   WAITING_OPERATION_RUN_STATUSES,
   WEB_SOURCE_PROVIDERS,
+  WORKFLOW_DATASET_DOWNLOAD_FORMATS,
+  WORKFLOW_DATASET_STATES,
   WORKFLOW_ENDED_STATUSES,
+  WORKFLOW_KINDS,
+  WORKFLOW_MARKDOWN_MAX_COLUMNS,
+  WORKFLOW_MARKDOWN_MAX_ROWS,
   WORKFLOW_NAME_PATTERN,
   WORKFLOW_NAME_RULE,
   WORKFLOW_RESERVED_STEP_TYPES,
+  WORKFLOW_RIGHTS_REVISIONS,
+  WORKFLOW_RIGHT_NEEDED_FOR,
+  WORKFLOW_RIGHT_REFUSALS,
+  WORKFLOW_RUN_ACCOUNT_STATUSES,
   WORKFLOW_RUN_MODES,
   WORKFLOW_RUN_STATUSES,
   WORKFLOW_STEP_RUN_STATUSES,
+  WORKFLOW_STEP_SOURCE_KINDS,
   WORKFLOW_STEP_TYPES,
+  WORKFLOW_TEXT_FORMAT_MARKDOWN,
+  WORKFLOW_TEXT_MAX_PARTS,
   WORKFLOW_TRIGGER_KINDS,
   WORKSPACE_ACCENT_COLORS,
   WORKSPACE_ACCESS_STATES,
@@ -1278,19 +2170,80 @@ export {
   WORKSPACE_FILE_KINDS,
   WORKSPACE_MEMBERSHIP_ROLES,
   WORKSPACE_SECTIONS,
+  WORKSPACE_USE_ASSET_KINDS,
   WORKSPACE_VISIBILITIES,
   YAML_DATA_MAX_VALUES,
   YamlDataError,
   agentConfigSchema,
   checkStorableTexts,
+  dataScopeNameSchema,
+  dataScopesSchema,
+  dataStoreRecordFieldSchema,
+  dataStoreRecordProposalItemSchema,
+  dataStoreRecordsContracts,
+  dataStoreRecordsDecideInputSchema,
+  dataStoreRecordsDecideOutputSchema,
+  dataStoreRecordsFlaggedInputSchema,
+  dataStoreRecordsFlaggedOutputSchema,
+  dataStoreRecordsProposeInputSchema,
+  dataStoreRecordsRuleSchema,
   deriveSkillTitle,
   formatSkillMarkdown,
   isStorableText,
+  knowledgeExtractFieldsInputSchema,
+  knowledgeExtractFieldsOutputSchema,
+  knowledgeFieldValueSchema,
+  knowledgeIngestFetchSchema,
+  knowledgeIngestInputSchema,
+  knowledgeIngestItemSchema,
+  knowledgeIngestOutputSchema,
+  knowledgeLocateInputSchema,
+  knowledgeLocateOutputSchema,
+  knowledgePendingInputSchema,
+  knowledgePendingOutputSchema,
+  knowledgePendingRowSchema,
+  knowledgeProcessorOutputSchema,
+  knowledgePutProcessedInputSchema,
+  knowledgeRecordsRefusalSchema,
+  knowledgeRetryInputSchema,
+  knowledgeRetryOutputSchema,
+  knowledgeSourceItemsInputSchema,
+  knowledgeSourceItemsOutputSchema,
+  knowledgeSourcesOutputSchema,
+  knowledgeSyncInputSchema,
+  knowledgeSyncResultSchema,
+  knowledgeWithdrawInputSchema,
+  knowledgeWithdrawOutputSchema,
+  knowledgeWorkflowSourceSchema,
+  knowledgeWriteContracts,
   loadYamlData,
   localeCodes,
   localizedStringSchema,
+  mailAddressSchema,
+  mailBodySchema,
+  mailCopyRecipientListSchema,
+  mailPreviewRecipientSchema,
+  mailRecipientDomainSchema,
+  mailRecipientListSchema,
+  mailRecipientSchema,
+  mailReplyToSchema,
+  mailSendContract,
+  mailSendInputSchema,
+  mailSendOutputSchema,
+  mailSendPreviewSchema,
+  mailSendRefusalDetailsSchema,
+  mailSendSimulatedOutputSchema,
+  mailSenderIdSchema,
+  mailSenderNameSchema,
+  mailSubjectSchema,
+  operationBatchFailureSchema,
+  operationBatchResultSchema,
+  operationPagingSchema,
   parseSkillMarkdown,
   readYamlData,
+  recordEvidenceResultSchema,
+  scopeAssignmentInputSchema,
+  scopedTablesSchema,
   skillConfigSchema,
   skillFileEntrySchema,
   skillFileFrontmatterSchema,
@@ -1301,6 +2254,10 @@ export {
   skillResourcePathSchema,
   skillStarterSchema,
   workflowConfigSchema,
+  workflowDataFlowsSchema,
+  workflowDatasetReferenceSchema,
+  workflowMailSenderFactSchema,
+  workflowMessageMailParamsSchema,
   yamlValueIssue,
   yamlValueIssueSentence
 };