@workflow-code/cli 0.2.4-20261011005.codex-cli-web → 0.2.4-20261011007.codex-cli-web

package/dist/chunk-HLMW6LAQ.js

@@ -0,0 +1,908 @@
+#!/usr/bin/env node
+import {
+  WORKFLOW_RELATED_PROJECT_ALIAS_PATTERN,
+  WORKFLOW_RELATED_PROJECT_KEY_LIMIT
+} from "./chunk-P6K3NB5S.js";
+
+// .shared/kanban-project/revision-stream.ts
+async function consumeKanbanRelatedProjectRevisionStream(stream, callbacks, signal) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let aborted = signal?.aborted === true;
+  const cancelReader = () => {
+    aborted = true;
+    void reader.cancel(signal?.reason).catch(() => void 0);
+  };
+  if (signal?.aborted) cancelReader();
+  else signal?.addEventListener("abort", cancelReader, { once: true });
+  try {
+    while (!aborted) {
+      const result = await reader.read();
+      buffer += decoder.decode(result.value, { stream: !result.done });
+      let boundary = findSseBoundary(buffer);
+      while (boundary !== void 0) {
+        const block = buffer.slice(0, boundary.index);
+        buffer = buffer.slice(boundary.index + boundary.length);
+        dispatchKanbanRevisionEvent(block, callbacks);
+        boundary = findSseBoundary(buffer);
+      }
+      if (result.done) break;
+    }
+    if (!aborted && buffer.trim() !== "") {
+      dispatchKanbanRevisionEvent(buffer, callbacks);
+    }
+  } finally {
+    signal?.removeEventListener("abort", cancelReader);
+    if (aborted) await reader.cancel(signal?.reason).catch(() => void 0);
+    reader.releaseLock();
+  }
+}
+function findSseBoundary(value) {
+  const lf = value.indexOf("\n\n");
+  const crlf = value.indexOf("\r\n\r\n");
+  if (lf < 0 && crlf < 0) return void 0;
+  if (crlf >= 0 && (lf < 0 || crlf < lf)) return { index: crlf, length: 4 };
+  return { index: lf, length: 2 };
+}
+function dispatchKanbanRevisionEvent(block, callbacks) {
+  let event = "message";
+  const data = [];
+  for (const line of block.split(/\r?\n/)) {
+    if (line.startsWith("event:")) event = line.slice("event:".length).trim();
+    if (line.startsWith("data:")) data.push(line.slice("data:".length).trimStart());
+  }
+  if (data.length === 0 || event === "heartbeat") return;
+  if (event === "unavailable") {
+    callbacks.onUnavailable?.();
+    return;
+  }
+  const value = JSON.parse(data.join("\n"));
+  if (event === "revision") {
+    const revision = readKanbanRevision(value);
+    callbacks.onRevision?.(revision);
+    return;
+  }
+  if (event === "snapshot") {
+    if (!isRecord(value) || typeof value["resolvedTarget"] !== "string" || !Array.isArray(value["revisions"])) {
+      throw new Error("Kanban related-project revision snapshot is invalid.");
+    }
+    const snapshot = {
+      resolvedTarget: value["resolvedTarget"],
+      revisions: value["revisions"].map(readKanbanRevision)
+    };
+    callbacks.onSnapshot?.(snapshot);
+  }
+}
+function readKanbanRevision(value) {
+  if (!isRecord(value) || typeof value["alias"] !== "string" || typeof value["revision"] !== "string" || value["alias"].trim() === "" || value["revision"].trim() === "") throw new Error("Kanban related-project revision event is invalid.");
+  return { alias: value["alias"], revision: value["revision"] };
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+// .shared/kanban-project/methods.ts
+var KANBAN_METHOD_CATALOG_MESSAGE = "workflow-code:kanban-method-catalog";
+var KANBAN_METHOD_INVOKE_MESSAGE = "workflow-code:kanban-method-invoke";
+var KANBAN_METHOD_RESULT_MESSAGE = "workflow-code:kanban-method-result";
+var KANBAN_METHOD_CANCEL_MESSAGE = "workflow-code:kanban-method-cancel";
+var KANBAN_METHOD_MAX_JSON_CHARS = 65536;
+var KANBAN_METHOD_TIMEOUT_MS = 15e3;
+var MAX_METHODS = 32;
+function parseKanbanMethodInvocation(value) {
+  if (!isRecord2(value) || Object.keys(value).some((key) => !["instanceId", "configurationId", "method", "args"].includes(key))) {
+    throw methodError("KANBAN_METHOD_INVALID_REQUEST", "Invalid Kanban method invocation.");
+  }
+  if (typeof value.instanceId !== "string" || !value.instanceId || value.instanceId.length > 200 || typeof value.configurationId !== "string" || value.configurationId.length > 200 || typeof value.method !== "string" || !/^[a-zA-Z][a-zA-Z0-9_.-]{0,79}$/.test(value.method) || !isRecord2(value.args)) {
+    throw methodError("KANBAN_METHOD_INVALID_REQUEST", "An instanceId, configurationId, method and JSON args object are required.");
+  }
+  assertKanbanMethodJson(value.args);
+  return value;
+}
+function assertKanbanMethodJson(value) {
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (node, depth) => {
+    if (depth > 32) return false;
+    if (node === null || typeof node === "string" || typeof node === "boolean") return true;
+    if (typeof node === "number") return Number.isFinite(node);
+    if (typeof node !== "object" || seen.has(node)) return false;
+    seen.add(node);
+    const valid = Array.isArray(node) ? node.every((item) => visit(item, depth + 1)) : Object.getPrototypeOf(node) === Object.prototype && Object.values(node).every((item) => visit(item, depth + 1));
+    seen.delete(node);
+    return valid;
+  };
+  if (!visit(value, 0) || JSON.stringify(value).length > KANBAN_METHOD_MAX_JSON_CHARS) {
+    throw methodError("KANBAN_METHOD_INVALID_JSON", "Kanban method data must be JSON, at most 32 levels deep and 64 Ki characters.");
+  }
+}
+function parseKanbanMethodDefinitions(value) {
+  assertKanbanMethodJson(value);
+  if (!Array.isArray(value) || value.length > MAX_METHODS) throw methodError("KANBAN_METHOD_INVALID_CATALOG", "Invalid Kanban method catalog.");
+  const names = /* @__PURE__ */ new Set();
+  for (const item of value) {
+    if (!isRecord2(item) || Object.keys(item).some((key) => !["name", "description", "inputSchema", "readOnly"].includes(key)) || typeof item.name !== "string" || !/^[a-zA-Z][a-zA-Z0-9_.-]{0,79}$/.test(item.name) || names.has(item.name) || typeof item.description !== "string" || !item.description.trim() || item.description.length > 2e3 || !isRecord2(item.inputSchema) || item.inputSchema.type !== "object" || JSON.stringify(item.inputSchema).length > 8192 || item.readOnly !== void 0 && typeof item.readOnly !== "boolean") {
+      throw methodError("KANBAN_METHOD_INVALID_CATALOG", "Invalid Kanban method definition.");
+    }
+    names.add(item.name);
+  }
+  return JSON.parse(JSON.stringify(value));
+}
+function methodError(code, message) {
+  return Object.assign(new Error(message), { code });
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function createKanbanMethodsBridgeScript(nonce) {
+  const safeNonce = JSON.stringify(nonce);
+  return `
+const registeredMethods=new Map();
+const methodDocumentId=Date.now().toString(36)+"-"+Math.random().toString(36).slice(2);
+const activeMethodCalls=new Map();
+const seenMethodCalls=new Set();
+let methodRevision=0;
+const methodPost=(message)=>window.parent.postMessage({...message,nonce:${safeNonce}},"*");
+const methodDepth=(value,depth=0)=>depth<=32&&(value===null||typeof value!=="object"||Object.values(value).every((item)=>methodDepth(item,depth+1)));
+const methodJson=(value)=>{try{if(!isJsonValue(value)||!methodDepth(value)||JSON.stringify(value).length>${KANBAN_METHOD_MAX_JSON_CHARS})throw invalidRequest();return JSON.parse(JSON.stringify(value));}catch{throw createError("Kanban method data must be bounded JSON.","KANBAN_METHOD_INVALID_JSON");}};
+const publishKanbanMethods=()=>methodPost({type:${JSON.stringify(KANBAN_METHOD_CATALOG_MESSAGE)},documentId:methodDocumentId,configurationId:current.id,revision:++methodRevision,methods:[...registeredMethods.values()].map((entry)=>entry.definition)});
+const finishMethodCall=(requestId,response)=>{
+  const entry=activeMethodCalls.get(requestId);if(!entry)return;
+  activeMethodCalls.delete(requestId);window.clearTimeout(entry.timer);
+  methodPost({type:${JSON.stringify(KANBAN_METHOD_RESULT_MESSAGE)},requestId,...response});
+};
+const abortMethodCall=(requestId,code,message)=>{const entry=activeMethodCalls.get(requestId);if(!entry)return;entry.controller.abort();finishMethodCall(requestId,{ok:false,error:{code,message}});};
+const resetKanbanMethods=()=>{registeredMethods.clear();for(const id of activeMethodCalls.keys())abortMethodCall(id,"KANBAN_METHOD_STALE","The Kanban configuration changed.");publishKanbanMethods();};
+const methods=Object.freeze({register:(definition,handler)=>{
+  const clean=methodJson(definition);
+  if(!clean||typeof clean!=="object"||Array.isArray(clean)||Object.keys(clean).some((key)=>!["name","description","inputSchema","readOnly"].includes(key))||typeof clean.name!=="string"||!/^[a-zA-Z][a-zA-Z0-9_.-]{0,79}$/.test(clean.name)||typeof clean.description!=="string"||!clean.description.trim()||clean.description.length>2000||!clean.inputSchema||clean.inputSchema.type!=="object"||JSON.stringify(clean.inputSchema).length>8192||(clean.readOnly!==undefined&&typeof clean.readOnly!=="boolean")||typeof handler!=="function"||registeredMethods.has(clean.name)||registeredMethods.size>=${MAX_METHODS})throw invalidRequest();
+  if(JSON.stringify([...registeredMethods.values()].map((entry)=>entry.definition).concat(clean)).length>${KANBAN_METHOD_MAX_JSON_CHARS})throw invalidRequest();
+  const entry={definition:clean,handler};registeredMethods.set(clean.name,entry);publishKanbanMethods();
+  return ()=>{if(registeredMethods.get(clean.name)!==entry)return;registeredMethods.delete(clean.name);for(const [id,call] of activeMethodCalls)if(call.method===clean.name)abortMethodCall(id,"KANBAN_METHOD_UNAVAILABLE","The Kanban method was unregistered.");publishKanbanMethods();};
+}});
+const handleKanbanMethodMessage=(data)=>{
+  if(data.type===${JSON.stringify(KANBAN_METHOD_CANCEL_MESSAGE)}){if(typeof data.requestId==="string")abortMethodCall(data.requestId,"KANBAN_METHOD_CANCELLED","Kanban method call was cancelled.");return true;}
+  if(data.type!==${JSON.stringify(KANBAN_METHOD_INVOKE_MESSAGE)})return false;
+  const requestId=data.requestId;if(typeof requestId!=="string"||!requestId||requestId.length>200||seenMethodCalls.has(requestId))return true;
+  seenMethodCalls.add(requestId);if(seenMethodCalls.size>128)seenMethodCalls.delete(seenMethodCalls.values().next().value);
+  const fail=(code,message)=>methodPost({type:${JSON.stringify(KANBAN_METHOD_RESULT_MESSAGE)},requestId,ok:false,error:{code,message}});
+  if(data.documentId!==methodDocumentId||data.configurationId!==current.id||data.revision!==methodRevision){fail("KANBAN_METHOD_STALE","The Kanban document, configuration or methods changed. List instances again.");return true;}
+  const method=registeredMethods.get(data.method);if(!method){fail("KANBAN_METHOD_UNAVAILABLE","The Kanban method is unavailable.");return true;}
+  if(activeMethodCalls.size>=4){fail("KANBAN_METHOD_BUSY","Too many Kanban method calls are pending.");return true;}
+  let input;try{input=methodJson(data.input);if(!input||typeof input!=="object"||Array.isArray(input))throw invalidRequest();}catch{fail("KANBAN_METHOD_INVALID_REQUEST","Kanban method input must be a JSON object.");return true;}
+  const controller=new AbortController();const timer=window.setTimeout(()=>abortMethodCall(requestId,"KANBAN_METHOD_TIMEOUT","Kanban method call timed out; inspect state before retrying."),${KANBAN_METHOD_TIMEOUT_MS});
+  activeMethodCalls.set(requestId,{controller,timer,method:data.method});
+  const context={signal:controller.signal,configuration:clone(),presentation:{...presentation}};
+  Promise.resolve().then(()=>{if(controller.signal.aborted)throw createError("Cancelled","KANBAN_METHOD_CANCELLED");return method.handler(input,context);})
+    .then((value)=>finishMethodCall(requestId,{ok:true,value:methodJson(value)}))
+    .catch((error)=>finishMethodCall(requestId,{ok:false,error:{code:"KANBAN_METHOD_FAILED",message:typeof error?.message==="string"?error.message.slice(0,2000):"Kanban method failed."}}));
+  return true;
+};
+window.addEventListener("pagehide",()=>{for(const id of activeMethodCalls.keys())abortMethodCall(id,"KANBAN_METHOD_INSTANCE_UNAVAILABLE","The Kanban page closed.");registeredMethods.clear();publishKanbanMethods();});
+`;
+}
+
+// .shared/kanban-project/index.ts
+var KANBAN_MANIFEST_FILE = "kanban.json";
+var KANBAN_ENTRY_FILE = "index.html";
+var KANBAN_ARTIFACT_DIR = ".";
+var KANBAN_MANIFEST_VERSION = 1;
+var KANBAN_CONFIGURATION_CHANGE_EVENT = "workflow-code:kanban-configuration-change";
+var KANBAN_PRESENTATION_CHANGE_EVENT = "workflow-code:kanban-presentation-change";
+var KANBAN_PRESENTATION_MESSAGE = "workflow-code:kanban-presentation";
+var KANBAN_PREVIEW_READY_MESSAGE = "workflow-code:kanban-ready";
+var KANBAN_BRIDGE_REQUEST_MESSAGE = "workflow-code:kanban-bridge-request";
+var KANBAN_BRIDGE_RESPONSE_MESSAGE = "workflow-code:kanban-bridge-response";
+var KANBAN_RELATED_PROJECT_REVISION_MESSAGE = "workflow-code:kanban-related-project-revision";
+var KANBAN_BRIDGE_REQUEST_TIMEOUT_MS = 15e3;
+var KANBAN_FILE_BRIDGE_REQUEST_TIMEOUT_MS = 12e4;
+var KANBAN_FILE_MAX_BYTES = 50 * 1024 * 1024;
+var KANBAN_BRIDGE_MAX_PENDING_REQUESTS = 16;
+var KANBAN_BRIDGE_SAFE_ERRORS = {
+  KANBAN_BRIDGE_INVALID_REQUEST: "The Kanban bridge request is invalid.",
+  KANBAN_BRIDGE_BUSY: "Too many Kanban bridge requests are pending.",
+  KANBAN_BRIDGE_TIMEOUT: "Kanban bridge request timed out.",
+  KANBAN_BRIDGE_UNAVAILABLE: "Kanban project data is unavailable in this host.",
+  KANBAN_BRIDGE_SESSION_INVALID: "The Kanban preview session is invalid or expired.",
+  KANBAN_BRIDGE_SERVER_ERROR: "Kanban project data operation failed.",
+  KANBAN_DATA_OPERATION_FAILED: "Kanban project data operation failed.",
+  KANBAN_RELATED_PROJECT_UNAVAILABLE: "Kanban related project is unavailable.",
+  KANBAN_FILE_UNAVAILABLE: "Kanban file is unavailable in this project.",
+  KANBAN_FILE_TOO_LARGE: "Kanban files cannot exceed 50 MiB."
+};
+var KANBAN_BRIDGE_CALL_FIELDS = /* @__PURE__ */ new Set(["requestId", "operation", "input"]);
+var MAX_KNOWLEDGE_DOCUMENT_PAGE_SIZE = 100;
+var MAX_KNOWLEDGE_SEARCH_PAGE_SIZE = 1e3;
+var MAX_KNOWLEDGE_CONTEXT_LINES = 50;
+var MAX_KNOWLEDGE_LINE_RANGE = 1e3;
+var KANBAN_BRIDGE_INPUT_FIELDS = {
+  "runtime.getLocale": [],
+  "files.createFile": ["name", "mimeType", "base64"],
+  "files.readFile": ["fileId"],
+  "files.deleteFile": ["fileId"],
+  "kv.getValue": ["key"],
+  "kv.setValue": ["key", "value"],
+  "relatedProject.kv.getValue": ["alias", "key"],
+  "relatedProject.kv.setValue": ["alias", "key", "value"],
+  "knowledge.listDocuments": ["pageSize", "cursor"],
+  "knowledge.getDocument": ["documentId"],
+  "knowledge.createDocument": ["id", "title", "markdown"],
+  "knowledge.editDocument": ["documentId", "title", "markdown"],
+  "knowledge.deleteDocument": ["documentId"],
+  "knowledge.searchDocuments": [
+    "query",
+    "documentId",
+    "beforeLines",
+    "afterLines",
+    "maxMatches",
+    "pageSize",
+    "cursor"
+  ],
+  "knowledge.readDocumentLines": ["documentId", "startLine", "endLine"]
+};
+function readPackageProjectType(value) {
+  if (!isRecord3(value)) return void 0;
+  const workflowCode = value["workflowCode"];
+  if (!isRecord3(workflowCode)) return void 0;
+  return workflowCode["projectType"] === "kanban" ? "kanban" : void 0;
+}
+function readKanbanArtifactConfig(value) {
+  if (!isRecord3(value)) {
+    throw new Error("package.json root must be an object.");
+  }
+  const workflowCode = value["workflowCode"];
+  if (!isRecord3(workflowCode)) {
+    throw new Error("package.json workflowCode must be an object for a Kanban project.");
+  }
+  const rawConfig = workflowCode["kanban"];
+  if (rawConfig !== void 0 && !isRecord3(rawConfig)) {
+    throw new Error("package.json workflowCode.kanban must be an object.");
+  }
+  if (rawConfig?.["dataSources"] !== void 0) {
+    throw new Error(
+      "package.json workflowCode.kanban.dataSources was removed; declare workflowCode.projectInfo.relatedProjects instead."
+    );
+  }
+  return {
+    artifactDir: readKanbanRelativePath(
+      rawConfig?.["artifactDir"],
+      "workflowCode.kanban.artifactDir",
+      KANBAN_ARTIFACT_DIR,
+      true
+    ),
+    entry: readKanbanRelativePath(
+      rawConfig?.["entry"],
+      "workflowCode.kanban.entry",
+      KANBAN_ENTRY_FILE,
+      false
+    )
+  };
+}
+function createKanbanArtifactEntryPath(config) {
+  return config.artifactDir === KANBAN_ARTIFACT_DIR ? config.entry : `${config.artifactDir}/${config.entry}`;
+}
+function encodeKanbanAssetUrlPath(filePath) {
+  return filePath.split("/").map((part) => encodeURIComponent(part)).join("/");
+}
+function readKanbanAssetMimeType(filePath) {
+  const normalized = filePath.split(/[?#]/, 1)[0]?.toLowerCase() ?? "";
+  const extension = normalized.includes(".") ? `.${normalized.split(".").at(-1)}` : "";
+  switch (extension) {
+    case ".html":
+    case ".htm":
+      return "text/html; charset=utf-8";
+    case ".css":
+      return "text/css; charset=utf-8";
+    case ".js":
+    case ".mjs":
+      return "text/javascript; charset=utf-8";
+    case ".json":
+    case ".map":
+      return "application/json; charset=utf-8";
+    case ".webmanifest":
+      return "application/manifest+json; charset=utf-8";
+    case ".svg":
+      return "image/svg+xml";
+    case ".png":
+      return "image/png";
+    case ".jpg":
+    case ".jpeg":
+      return "image/jpeg";
+    case ".gif":
+      return "image/gif";
+    case ".webp":
+      return "image/webp";
+    case ".avif":
+      return "image/avif";
+    case ".ico":
+      return "image/x-icon";
+    case ".woff":
+      return "font/woff";
+    case ".woff2":
+      return "font/woff2";
+    case ".ttf":
+      return "font/ttf";
+    case ".otf":
+      return "font/otf";
+    case ".eot":
+      return "application/vnd.ms-fontobject";
+    case ".wasm":
+      return "application/wasm";
+    case ".mp3":
+      return "audio/mpeg";
+    case ".ogg":
+      return "audio/ogg";
+    case ".wav":
+      return "audio/wav";
+    case ".mp4":
+      return "video/mp4";
+    case ".webm":
+      return "video/webm";
+    case ".txt":
+      return "text/plain; charset=utf-8";
+    case ".xml":
+      return "application/xml; charset=utf-8";
+    case ".pdf":
+      return "application/pdf";
+    default:
+      return "application/octet-stream";
+  }
+}
+function parseKanbanManifest(value) {
+  if (!isRecord3(value)) {
+    throw new Error("kanban.json root must be an object.");
+  }
+  if (value["version"] !== KANBAN_MANIFEST_VERSION) {
+    throw new Error(`kanban.json version must be ${KANBAN_MANIFEST_VERSION}.`);
+  }
+  const rawParams = value["params"];
+  if (!Array.isArray(rawParams)) {
+    throw new Error("kanban.json params must be an array.");
+  }
+  const names = /* @__PURE__ */ new Set();
+  const params = rawParams.map((param, index) => parseParam(param, index, names));
+  return { version: KANBAN_MANIFEST_VERSION, params };
+}
+function parseKanbanManifestText(content) {
+  try {
+    return parseKanbanManifest(JSON.parse(content));
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error("kanban.json must contain valid JSON.");
+    }
+    throw error;
+  }
+}
+function createDefaultKanbanValues(params) {
+  return Object.fromEntries(params.map((param) => [param.name, param.defaultValue ?? ""]));
+}
+function sanitizeKanbanValues(params, values) {
+  const next = {};
+  for (const param of params) {
+    const value = values[param.name];
+    next[param.name] = typeof value === "string" ? value : param.defaultValue ?? "";
+  }
+  return next;
+}
+function createInjectedKanbanParams(params, values) {
+  return Object.fromEntries(params.map((param) => [
+    param.name,
+    parseInjectedValue(param, values[param.name] ?? param.defaultValue ?? "")
+  ]));
+}
+function createKanbanBridgeScript(configuration, nonce) {
+  const initial = JSON.stringify(configuration).replaceAll("<", "\\u003c");
+  const safeNonce = JSON.stringify(nonce);
+  const eventName = JSON.stringify(KANBAN_CONFIGURATION_CHANGE_EVENT);
+  const readyMessage = JSON.stringify(KANBAN_PREVIEW_READY_MESSAGE);
+  const requestMessage = JSON.stringify(KANBAN_BRIDGE_REQUEST_MESSAGE);
+  const responseMessage = JSON.stringify(KANBAN_BRIDGE_RESPONSE_MESSAGE);
+  const revisionMessage = JSON.stringify(KANBAN_RELATED_PROJECT_REVISION_MESSAGE);
+  const presentationMessage = JSON.stringify(KANBAN_PRESENTATION_MESSAGE);
+  const presentationEvent = JSON.stringify(KANBAN_PRESENTATION_CHANGE_EVENT);
+  const safeErrorMessages = JSON.stringify(KANBAN_BRIDGE_SAFE_ERRORS);
+  return `<script nonce=${safeNonce}>(function(){
+let current=${initial};
+let presentation={mode:"fullscreen"};
+let sequence=0;
+const safeErrorMessages=${safeErrorMessages};
+const pending=new Map();
+const relatedProjectRevisions=new Map();
+const relatedProjectRevisionListeners=new Map();
+const clone=()=>JSON.parse(JSON.stringify(current));
+const createError=(message,code)=>{const error=new Error(message);if(code)Object.defineProperty(error,"code",{value:code,enumerable:true});return error;};
+const invalidRequest=()=>createError("The Kanban bridge request is invalid.","KANBAN_BRIDGE_INVALID_REQUEST");
+const isSafeErrorCode=(code)=>typeof code==="string"&&Object.prototype.hasOwnProperty.call(safeErrorMessages,code);
+const isJsonValue=(value,seen=new Set())=>{
+  if(value===null||typeof value==="string"||typeof value==="boolean")return true;
+  if(typeof value==="number")return Number.isFinite(value);
+  if(typeof value!=="object"||seen.has(value))return false;
+  seen.add(value);
+  let valid=false;
+  try{valid=Array.isArray(value)?value.every((item)=>isJsonValue(item,seen)):Object.getPrototypeOf(value)===Object.prototype&&Object.values(value).every((item)=>isJsonValue(item,seen));}
+  catch{return false;}
+  finally{seen.delete(value);}
+  return valid;
+};
+const ready=()=>{window.parent.postMessage({type:${readyMessage},nonce:${safeNonce},documentId:methodDocumentId},"*");publishKanbanMethods();};
+const request=(operation,input)=>{
+  if(pending.size>=${KANBAN_BRIDGE_MAX_PENDING_REQUESTS})return Promise.reject(createError("Too many Kanban bridge requests are pending.","KANBAN_BRIDGE_BUSY"));
+  const requestId=Date.now().toString(36)+"-"+(++sequence).toString(36);
+  return new Promise((resolve,reject)=>{
+    const timeout=window.setTimeout(()=>{pending.delete(requestId);reject(createError("Kanban bridge request timed out.","KANBAN_BRIDGE_TIMEOUT"));},operation.startsWith("files.")?${KANBAN_FILE_BRIDGE_REQUEST_TIMEOUT_MS}:${KANBAN_BRIDGE_REQUEST_TIMEOUT_MS});
+    pending.set(requestId,{resolve,reject,timeout});
+    try{window.parent.postMessage({type:${requestMessage},nonce:${safeNonce},requestId,operation,input},"*");}
+    catch{window.clearTimeout(timeout);pending.delete(requestId);reject(invalidRequest());}
+  });
+};
+const kv=Object.freeze({
+  getValue:(key)=>request("kv.getValue",{key}),
+  setValue:(key,value)=>isJsonValue(value)?request("kv.setValue",{key,value}).then(()=>undefined):Promise.reject(invalidRequest())
+});
+const files=Object.freeze({
+  createFile:async(input)=>{
+    if(!input||typeof input.name!=="string")throw invalidRequest();
+    const source=input.buffer;
+    if(!(source instanceof Blob)&&!(source instanceof ArrayBuffer)&&!(source instanceof Uint8Array))throw invalidRequest();
+    if((source instanceof Blob?source.size:source.byteLength)>${KANBAN_FILE_MAX_BYTES})throw createError(safeErrorMessages.KANBAN_FILE_TOO_LARGE,"KANBAN_FILE_TOO_LARGE");
+    const bytes=source instanceof Blob?new Uint8Array(await source.arrayBuffer()):source instanceof ArrayBuffer?new Uint8Array(source):source;
+    let binary="";
+    for(let offset=0;offset<bytes.length;offset+=32768)binary+=String.fromCharCode(...bytes.subarray(offset,offset+32768));
+    return request("files.createFile",{name:input.name,mimeType:input.mimeType||(source instanceof Blob?source.type:undefined)||undefined,base64:btoa(binary)});
+  },
+  readFile:(fileId)=>request("files.readFile",{fileId}).then(({file,base64})=>({file,buffer:Uint8Array.from(atob(base64),(char)=>char.charCodeAt(0)).buffer})),
+  deleteFile:(fileId)=>request("files.deleteFile",{fileId})
+});
+const subscribeToRelatedProject=(alias,listener)=>{
+  if(typeof listener!=="function")throw invalidRequest();
+  let listeners=relatedProjectRevisionListeners.get(alias);
+  if(!listeners){listeners=new Set();relatedProjectRevisionListeners.set(alias,listeners);}
+  listeners.add(listener);
+  if(relatedProjectRevisions.has(alias)){const revision=relatedProjectRevisions.get(alias);Promise.resolve().then(()=>{if(listeners.has(listener))listener({alias,revision});}).catch(()=>{});}
+  return ()=>{listeners.delete(listener);if(listeners.size===0)relatedProjectRevisionListeners.delete(alias);};
+};
+const relatedProjectContexts=new Map();
+const relatedProjects=Object.freeze({
+  get:(alias)=>{
+    if(typeof alias!=="string"||!${WORKFLOW_RELATED_PROJECT_ALIAS_PATTERN.toString()}.test(alias))throw invalidRequest();
+    if(relatedProjectContexts.has(alias))return relatedProjectContexts.get(alias);
+    const context=Object.freeze({kv:Object.freeze({
+      getValue:(key)=>request("relatedProject.kv.getValue",{alias,key}),
+      setValue:(key,value)=>isJsonValue(value)?request("relatedProject.kv.setValue",{alias,key,value}).then(()=>undefined):Promise.reject(invalidRequest()),
+      subscribe:(listener)=>subscribeToRelatedProject(alias,listener)
+    })});
+    relatedProjectContexts.set(alias,context);
+    return context;
+  }
+});
+const knowledge=Object.freeze({
+  listDocuments:(options={})=>request("knowledge.listDocuments",options),
+  getDocument:(documentId)=>request("knowledge.getDocument",{documentId}),
+  createDocument:(input)=>request("knowledge.createDocument",input),
+  editDocument:(documentId,input)=>request("knowledge.editDocument",{...input,documentId}),
+  deleteDocument:(documentId)=>request("knowledge.deleteDocument",{documentId}),
+  searchDocuments:(options)=>request("knowledge.searchDocuments",options),
+  readDocumentLines:(documentId,options)=>request("knowledge.readDocumentLines",{...options,documentId})
+});
+${createKanbanMethodsBridgeScript(nonce)}
+Object.defineProperty(window,"workflowCodeKanban",{configurable:false,enumerable:true,value:Object.freeze({getConfiguration:clone,getPresentation:()=>({...presentation}),getRuntimeLocale:()=>request("runtime.getLocale",{}),kv,files,relatedProjects,knowledge,methods})});
+window.addEventListener("message",function(event){
+  if(event.source!==window.parent||!event.data||event.data.nonce!==${safeNonce})return;
+  if(handleKanbanMethodMessage(event.data))return;
+  if(event.data.type===${presentationMessage}){
+    const mode=event.data.presentation?.mode;
+    if(!["fullscreen","phone","tablet","card"].includes(mode)||presentation.mode===mode)return;
+    presentation={mode};
+    window.dispatchEvent(new CustomEvent(${presentationEvent},{detail:{...presentation}}));
+    return;
+  }
+  if(event.data.type==="workflow-code:kanban-configuration"){
+    if(event.data.configuration?.id!==current.id)resetKanbanMethods();
+    current=event.data.configuration;
+    window.dispatchEvent(new CustomEvent(${eventName},{detail:clone()}));
+    ready();
+    return;
+  }
+  if(event.data.type===${revisionMessage}){
+    const alias=event.data.alias;
+    const revision=event.data.revision;
+    if(typeof alias!=="string"||!${WORKFLOW_RELATED_PROJECT_ALIAS_PATTERN.toString()}.test(alias)||typeof revision!=="string"||revision.length===0||revision.length>512)return;
+    if(relatedProjectRevisions.get(alias)===revision)return;
+    relatedProjectRevisions.set(alias,revision);
+    const listeners=relatedProjectRevisionListeners.get(alias);
+    if(listeners)for(const listener of [...listeners])Promise.resolve().then(()=>listener({alias,revision})).catch(()=>{});
+    return;
+  }
+  if(event.data.type!==${responseMessage}||typeof event.data.requestId!=="string")return;
+  const entry=pending.get(event.data.requestId);
+  if(!entry)return;
+  pending.delete(event.data.requestId);
+  window.clearTimeout(entry.timeout);
+  if(event.data.ok===true)entry.resolve(event.data.value);
+  else{const code=event.data.error?.code;const safe=isSafeErrorCode(code);entry.reject(createError(safe?safeErrorMessages[code]:"Kanban bridge request failed.",safe?code:"KANBAN_BRIDGE_ERROR"));}
+});
+if(document.readyState==="loading")window.addEventListener("DOMContentLoaded",ready,{once:true});else ready();
+})();</script>`;
+}
+function parseKanbanBridgeCall(value) {
+  if (!isRecord3(value)) throw new Error("Kanban bridge request must be an object.");
+  if (Object.keys(value).some((key) => !KANBAN_BRIDGE_CALL_FIELDS.has(key))) {
+    throw new Error("Kanban bridge request contains unsupported fields.");
+  }
+  const requestId = readNonEmptyString(value["requestId"], "bridge.requestId");
+  const operation = value["operation"];
+  if (!isKanbanBridgeOperation(operation)) {
+    throw new Error(`Unsupported Kanban bridge operation "${String(operation)}".`);
+  }
+  const input = value["input"];
+  if (!isRecord3(input)) throw new Error("Kanban bridge input must be an object.");
+  validateKanbanBridgeInput(operation, input);
+  return { requestId, operation, input };
+}
+function createKanbanBridgeError(reason) {
+  if (isRecord3(reason)) {
+    const code = reason["code"];
+    if (typeof code === "string" && Object.prototype.hasOwnProperty.call(KANBAN_BRIDGE_SAFE_ERRORS, code)) {
+      return {
+        code,
+        message: KANBAN_BRIDGE_SAFE_ERRORS[code]
+      };
+    }
+  }
+  return {
+    code: "KANBAN_BRIDGE_ERROR",
+    message: "Kanban bridge request failed."
+  };
+}
+function isKanbanJsonValue(value, seen = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (typeof value !== "object") return false;
+  if (seen.has(value)) return false;
+  seen.add(value);
+  const valid = Array.isArray(value) ? value.every((item) => isKanbanJsonValue(item, seen)) : Object.getPrototypeOf(value) === Object.prototype && Object.values(value).every((item) => isKanbanJsonValue(item, seen));
+  seen.delete(value);
+  return valid;
+}
+function injectKanbanBridge(html, configuration, nonce) {
+  const bridge = createKanbanBridgeScript(configuration, nonce);
+  const htmlWithNoncedScripts = html.replace(/<script\b([^>]*)>/gi, (tag, attributes) => {
+    if (/\bsrc\s*=/.test(attributes)) return tag;
+    const withoutNonce = attributes.replace(/\s+nonce\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]+)/gi, "");
+    return `<script nonce=${JSON.stringify(nonce)}${withoutNonce}>`;
+  });
+  const headMatch = /<head(?:\s[^>]*)?>/i.exec(htmlWithNoncedScripts);
+  if (headMatch?.index !== void 0) {
+    const index = headMatch.index + headMatch[0].length;
+    return `${htmlWithNoncedScripts.slice(0, index)}${bridge}${htmlWithNoncedScripts.slice(index)}`;
+  }
+  return `${bridge}${htmlWithNoncedScripts}`;
+}
+function createKanbanContentSecurityPolicy(nonce) {
+  return [
+    "default-src 'self' data: blob:",
+    `script-src 'self' 'nonce-${nonce}' 'wasm-unsafe-eval'`,
+    "style-src 'self' 'unsafe-inline'",
+    "img-src 'self' data: blob:",
+    "font-src 'self' data:",
+    "media-src 'self' data: blob:",
+    "connect-src 'self' data: blob:",
+    "object-src 'none'",
+    "base-uri 'self'"
+  ].join("; ");
+}
+function isSafeKanbanAssetPath(filePath) {
+  const normalized = filePath.replaceAll("\\", "/");
+  if (normalized === "" || normalized.startsWith("/") || normalized.includes("\0")) return false;
+  const parts = normalized.split("/");
+  if (parts.some((part) => part === "" || part === "." || part === "..")) return false;
+  const lowerParts = parts.map((part) => part.toLowerCase());
+  if (lowerParts.some((part) => part.startsWith(".") || part === "node_modules" || part === "package.json" || part === "kanban.json" || part === "package-lock.json" || part === "pnpm-lock.yaml" || part === "yarn.lock" || part === "readme.md")) return false;
+  return true;
+}
+function isSafeKanbanPublicAssetPath(filePath, entry = KANBAN_ENTRY_FILE) {
+  const normalized = filePath.replaceAll("\\", "/");
+  return normalized === entry || isSafeKanbanAssetPath(normalized);
+}
+function readKanbanRelativePath(value, field, fallback, allowDot) {
+  const raw = value === void 0 ? fallback : value;
+  if (typeof raw !== "string" || raw.trim() === "") {
+    throw new Error(`package.json ${field} must be a non-empty string.`);
+  }
+  const normalized = raw.trim().replaceAll("\\", "/").replace(/\/+$/, "");
+  if (allowDot && normalized === ".") return normalized;
+  if (normalized === "" || normalized === "." || normalized.startsWith("/") || normalized.startsWith("//") || /^[a-zA-Z]:/.test(normalized) || normalized.includes("\0") || normalized.split("/").some((part) => part === "" || part === "." || part === "..")) {
+    throw new Error(`package.json ${field} must be a safe project-relative path.`);
+  }
+  const reservedDirectory = normalized.split("/").find((part) => [".git", ".hg", ".svn", "node_modules"].includes(part.toLowerCase()));
+  if (reservedDirectory !== void 0) {
+    throw new Error(
+      `package.json ${field} must not use reserved directory ${JSON.stringify(reservedDirectory)}.`
+    );
+  }
+  if (!allowDot && !/\.html?$/i.test(normalized)) {
+    throw new Error(`package.json ${field} must point to an HTML file.`);
+  }
+  return normalized;
+}
+function parseParam(value, index, names) {
+  if (!isRecord3(value)) throw new Error(`kanban.json params[${index}] must be an object.`);
+  const name = readNonEmptyString(value["name"], `params[${index}].name`);
+  if (names.has(name)) throw new Error(`kanban.json contains duplicate param name "${name}".`);
+  names.add(name);
+  const type = value["type"];
+  if (!isParamType(type)) throw new Error(`kanban.json params[${index}].type is unsupported.`);
+  const control = value["control"];
+  if (control !== void 0 && !isParamControl(control)) {
+    throw new Error(`kanban.json params[${index}].control is unsupported.`);
+  }
+  const panel = value["panel"];
+  if (panel !== void 0 && panel !== "main" && panel !== "auxiliary" && panel !== "quick") {
+    throw new Error(`kanban.json params[${index}].panel is unsupported.`);
+  }
+  const options = value["options"];
+  if (options !== void 0 && !Array.isArray(options)) {
+    throw new Error(`kanban.json params[${index}].options must be an array.`);
+  }
+  return {
+    name,
+    type,
+    ...readOptionalString(value["flag"]) === void 0 ? {} : { flag: readOptionalString(value["flag"]) },
+    ...readOptionalString(value["shortFlag"]) === void 0 ? {} : { shortFlag: readOptionalString(value["shortFlag"]) },
+    ...typeof value["required"] === "boolean" ? { required: value["required"] } : {},
+    ...readOptionalString(value["label"]) === void 0 ? {} : { label: readOptionalString(value["label"]) },
+    ...readOptionalString(value["description"]) === void 0 ? {} : { description: readOptionalString(value["description"]) },
+    ...typeof value["defaultValue"] === "string" ? { defaultValue: value["defaultValue"] } : {},
+    ...typeof value["multiple"] === "boolean" ? { multiple: value["multiple"] } : {},
+    ...control === void 0 ? {} : { control },
+    ...panel === void 0 ? {} : { panel },
+    ...typeof value["resolveOnInput"] === "boolean" ? { resolveOnInput: value["resolveOnInput"] } : {},
+    ...options === void 0 ? {} : { options: options.map((option, optionIndex) => parseOption(option, index, optionIndex)) },
+    ...Array.isArray(value["accept"]) && value["accept"].every((item) => typeof item === "string") ? { accept: value["accept"] } : {},
+    ...value["format"] === "json" ? { format: "json" } : {}
+  };
+}
+function validateKanbanBridgeInput(operation, input) {
+  const allowedFields = new Set(KANBAN_BRIDGE_INPUT_FIELDS[operation]);
+  if (Object.keys(input).some((key) => !allowedFields.has(key))) {
+    throw new Error(`Kanban bridge ${operation} input contains unsupported fields.`);
+  }
+  switch (operation) {
+    case "runtime.getLocale":
+      return;
+    case "files.createFile": {
+      const name = readNonEmptyString(input["name"], "bridge.input.name");
+      if (name.length > 255 || /[\\/\\\\\0]/.test(name)) {
+        throw new Error("Kanban file name must be a plain file name.");
+      }
+      const mimeType = readOptionalNonEmptyString(input["mimeType"], "bridge.input.mimeType");
+      if (mimeType !== void 0 && !/^[a-zA-Z0-9!#$&^_.+-]+\/[a-zA-Z0-9!#$&^_.+-]+$/.test(mimeType)) {
+        throw new Error("Kanban file MIME type is invalid.");
+      }
+      const base64 = readRequiredString(input["base64"], "bridge.input.base64");
+      if (base64.length > Math.ceil(KANBAN_FILE_MAX_BYTES / 3) * 4) {
+        throw Object.assign(new Error(KANBAN_BRIDGE_SAFE_ERRORS.KANBAN_FILE_TOO_LARGE), { code: "KANBAN_FILE_TOO_LARGE" });
+      }
+      if (base64.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(base64)) {
+        throw new Error("Kanban file content must be base64 encoded.");
+      }
+      const size = base64.length / 4 * 3 - (base64.endsWith("==") ? 2 : base64.endsWith("=") ? 1 : 0);
+      if (size > KANBAN_FILE_MAX_BYTES) {
+        throw Object.assign(new Error(KANBAN_BRIDGE_SAFE_ERRORS.KANBAN_FILE_TOO_LARGE), { code: "KANBAN_FILE_TOO_LARGE" });
+      }
+      return;
+    }
+    case "files.readFile":
+    case "files.deleteFile":
+      if (!/^wf_[a-f0-9]+$/.test(readNonEmptyString(input["fileId"], "bridge.input.fileId"))) {
+        throw new Error("Kanban file id is invalid.");
+      }
+      return;
+    case "kv.getValue":
+      readNonEmptyString(input["key"], "bridge.input.key");
+      return;
+    case "kv.setValue":
+      readNonEmptyString(input["key"], "bridge.input.key");
+      if (input["value"] === void 0 || !isKanbanJsonValue(input["value"])) {
+        throw new Error("Kanban bridge KV value must be JSON-serializable and cannot be undefined.");
+      }
+      return;
+    case "relatedProject.kv.getValue":
+    case "relatedProject.kv.setValue": {
+      const alias = readNonEmptyString(input["alias"], "bridge.input.alias");
+      if (!WORKFLOW_RELATED_PROJECT_ALIAS_PATTERN.test(alias)) {
+        throw new Error("Kanban bridge related-project alias is invalid.");
+      }
+      const key = readNonEmptyString(input["key"], "bridge.input.key");
+      if (key.length > WORKFLOW_RELATED_PROJECT_KEY_LIMIT) {
+        throw new Error("Kanban bridge related-project key is too long.");
+      }
+      if (operation === "relatedProject.kv.setValue" && (input["value"] === void 0 || !isKanbanJsonValue(input["value"]))) {
+        throw new Error(
+          "Kanban bridge related-project KV value must be JSON-serializable and cannot be undefined."
+        );
+      }
+      return;
+    }
+    case "knowledge.listDocuments":
+      readOptionalIntegerInRange(
+        input["pageSize"],
+        "bridge.input.pageSize",
+        1,
+        MAX_KNOWLEDGE_DOCUMENT_PAGE_SIZE
+      );
+      readOptionalNonEmptyString(input["cursor"], "bridge.input.cursor");
+      return;
+    case "knowledge.getDocument":
+    case "knowledge.deleteDocument":
+      readNonEmptyString(input["documentId"], "bridge.input.documentId");
+      return;
+    case "knowledge.createDocument":
+      readOptionalNonEmptyString(input["id"], "bridge.input.id");
+      readNonEmptyString(input["title"], "bridge.input.title");
+      readRequiredString(input["markdown"], "bridge.input.markdown");
+      return;
+    case "knowledge.editDocument":
+      readNonEmptyString(input["documentId"], "bridge.input.documentId");
+      if (input["title"] === void 0 && input["markdown"] === void 0) {
+        throw new Error("Kanban bridge knowledge edit requires title or markdown.");
+      }
+      readOptionalStringValue(input["title"], "bridge.input.title");
+      readOptionalStringValue(input["markdown"], "bridge.input.markdown");
+      return;
+    case "knowledge.searchDocuments":
+      readNonEmptyString(input["query"], "bridge.input.query");
+      readOptionalNonEmptyString(input["documentId"], "bridge.input.documentId");
+      readOptionalIntegerInRange(
+        input["beforeLines"],
+        "bridge.input.beforeLines",
+        0,
+        MAX_KNOWLEDGE_CONTEXT_LINES
+      );
+      readOptionalIntegerInRange(
+        input["afterLines"],
+        "bridge.input.afterLines",
+        0,
+        MAX_KNOWLEDGE_CONTEXT_LINES
+      );
+      readOptionalIntegerInRange(
+        input["maxMatches"],
+        "bridge.input.maxMatches",
+        1,
+        MAX_KNOWLEDGE_SEARCH_PAGE_SIZE
+      );
+      readOptionalIntegerInRange(
+        input["pageSize"],
+        "bridge.input.pageSize",
+        1,
+        MAX_KNOWLEDGE_SEARCH_PAGE_SIZE
+      );
+      readOptionalNonEmptyString(input["cursor"], "bridge.input.cursor");
+      return;
+    case "knowledge.readDocumentLines":
+      readNonEmptyString(input["documentId"], "bridge.input.documentId");
+      const startLine = readPositiveInteger(input["startLine"], "bridge.input.startLine");
+      const endLine = readPositiveInteger(input["endLine"], "bridge.input.endLine");
+      if (endLine < startLine || endLine - startLine + 1 > MAX_KNOWLEDGE_LINE_RANGE) {
+        throw new Error("Kanban bridge knowledge line range is invalid or too large.");
+      }
+  }
+}
+function isKanbanBridgeOperation(value) {
+  return value === "runtime.getLocale" || value === "files.createFile" || value === "files.readFile" || value === "files.deleteFile" || value === "kv.getValue" || value === "kv.setValue" || value === "relatedProject.kv.getValue" || value === "relatedProject.kv.setValue" || value === "knowledge.listDocuments" || value === "knowledge.getDocument" || value === "knowledge.createDocument" || value === "knowledge.editDocument" || value === "knowledge.deleteDocument" || value === "knowledge.searchDocuments" || value === "knowledge.readDocumentLines";
+}
+function readRequiredString(value, field) {
+  if (typeof value !== "string") throw new Error(`Kanban ${field} must be a string.`);
+  return value;
+}
+function readOptionalStringValue(value, field) {
+  if (value === void 0) return void 0;
+  return readRequiredString(value, field);
+}
+function readOptionalNonEmptyString(value, field) {
+  if (value === void 0) return void 0;
+  return readNonEmptyString(value, field);
+}
+function readOptionalIntegerInRange(value, field, minimum, maximum) {
+  if (value === void 0) return void 0;
+  if (!Number.isInteger(value) || value < minimum || value > maximum) {
+    throw new Error(`Kanban ${field} must be an integer from ${minimum} to ${maximum}.`);
+  }
+  return value;
+}
+function readPositiveInteger(value, field) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error(`Kanban ${field} must be a positive integer.`);
+  }
+  return value;
+}
+function parseOption(value, paramIndex, optionIndex) {
+  if (!isRecord3(value)) {
+    throw new Error(`kanban.json params[${paramIndex}].options[${optionIndex}] must be an object.`);
+  }
+  return {
+    value: readNonEmptyString(value["value"], `params[${paramIndex}].options[${optionIndex}].value`),
+    ...readOptionalString(value["label"]) === void 0 ? {} : { label: readOptionalString(value["label"]) },
+    ...readOptionalString(value["description"]) === void 0 ? {} : { description: readOptionalString(value["description"]) }
+  };
+}
+function parseInjectedValue(param, value) {
+  if (param.type === "file") {
+    try {
+      const parsed = JSON.parse(value);
+      const values = Array.isArray(parsed) ? parsed : [parsed];
+      return values.map(sanitizeInjectedFileReference).filter((file) => file !== null);
+    } catch {
+      return [];
+    }
+  }
+  if (param.control === "checkboxes" || param.multiple) {
+    try {
+      const parsed = JSON.parse(value);
+      return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
+    } catch {
+      return [];
+    }
+  }
+  if (param.type === "number") {
+    const parsed = Number(value);
+    return value.trim() !== "" && Number.isFinite(parsed) ? parsed : null;
+  }
+  if (param.type === "boolean") return value === "true";
+  return value;
+}
+function sanitizeInjectedFileReference(value) {
+  if (!isRecord3(value) || typeof value["id"] !== "string" || value["id"].trim() === "" || value["storage"] !== "local" && value["storage"] !== "server") {
+    return null;
+  }
+  const mimeType = typeof value["mimeType"] === "string" ? value["mimeType"] : "application/octet-stream";
+  return {
+    id: value["id"],
+    name: typeof value["name"] === "string" ? value["name"] : value["id"],
+    mimeType,
+    size: typeof value["size"] === "number" && Number.isFinite(value["size"]) ? Math.max(0, value["size"]) : 0,
+    kind: value["kind"] === "image" || mimeType.startsWith("image/") ? "image" : "file",
+    storage: value["storage"],
+    ...typeof value["workflowId"] === "string" ? { workflowId: value["workflowId"] } : {},
+    ...typeof value["conversationId"] === "string" ? { conversationId: value["conversationId"] } : {},
+    ...typeof value["createdAt"] === "string" ? { createdAt: value["createdAt"] } : {}
+  };
+}
+function readNonEmptyString(value, field) {
+  if (typeof value !== "string" || value.trim() === "") throw new Error(`kanban.json ${field} must be a non-empty string.`);
+  return value.trim();
+}
+function readOptionalString(value) {
+  return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+}
+function isParamType(value) {
+  return value === "string" || value === "number" || value === "boolean" || value === "positional" || value === "file";
+}
+function isParamControl(value) {
+  return value === "text" || value === "textarea" || value === "radio" || value === "select" || value === "checkboxes";
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export {
+  parseKanbanMethodInvocation,
+  assertKanbanMethodJson,
+  parseKanbanMethodDefinitions,
+  consumeKanbanRelatedProjectRevisionStream,
+  KANBAN_MANIFEST_FILE,
+  readPackageProjectType,
+  readKanbanArtifactConfig,
+  createKanbanArtifactEntryPath,
+  encodeKanbanAssetUrlPath,
+  readKanbanAssetMimeType,
+  parseKanbanManifestText,
+  createDefaultKanbanValues,
+  sanitizeKanbanValues,
+  createInjectedKanbanParams,
+  parseKanbanBridgeCall,
+  createKanbanBridgeError,
+  injectKanbanBridge,
+  createKanbanContentSecurityPolicy,
+  isSafeKanbanPublicAssetPath
+};