clay-server 3.8.1 → 4.0.0-beta.1

package/lib/session-pair-mcp-server.js

@@ -6,14 +6,14 @@ function getToolDefs(handlers) {
   return [
     {
       name: "send_to_partner",
-      description: "Delegate one concrete task to the Worker. If this session has no pair yet, Clay creates a real Worker session and opens it visibly in the right pane before starting the task. A completed turn does not end the Worker session: reuse the same Worker for follow-up implementation and corrections instead of taking over its work. Detached completions are pushed back automatically. A delegated turn cannot delegate back, so keep orchestration one hop deep.",
+      description: "Delegate one concrete task to the visible Split Worker. If this session has no pair yet, Clay creates a real Split Worker session and opens it visibly in the right pane before starting the task. A completed turn does not end the Split Worker session: reuse the same Split Worker for follow-up implementation and corrections instead of taking over its work. Detached completions are pushed back automatically. A delegated turn cannot delegate back, so keep orchestration one hop deep.",
       inputSchema: buildShape({
         message: { type: "string", description: "The complete task or question for the partner." },
         wait: { type: "boolean", description: "Wait for the partner's turn to finish. Defaults to true." },
         timeoutSeconds: { type: "number", description: "Maximum wait in seconds, from 1 to 900. Defaults to 300." },
-        workerVendor: { type: "string", description: "Optional Worker vendor to use only when creating a new pair. Defaults to a suitable installed vendor." },
-        workerModel: { type: "string", description: "Optional Worker model to use only when creating a new pair." },
-        workerEffort: { type: "string", description: "Optional Worker reasoning effort to use only when creating a new pair." },
+        workerVendor: { type: "string", description: "Optional Split Worker vendor to use only when creating a new pair. Defaults to a suitable installed vendor." },
+        workerModel: { type: "string", description: "Optional Split Worker model to use only when creating a new pair." },
+        workerEffort: { type: "string", description: "Optional Split Worker reasoning effort to use only when creating a new pair." },
       }, ["message"]),
       handler: function (args) { return handlers.send(args || {}); },
     },
@@ -27,13 +27,13 @@ function getToolDefs(handlers) {
     },
     {
       name: "interrupt_partner",
-      description: "Interrupt the Worker's current task. Use this when the task is going in the wrong direction, needs to be reprioritized, or must stop before the next instruction. The Worker returns any partial result to you for review.",
+      description: "Interrupt the Split Worker's current task. Use this when the task is going in the wrong direction, needs to be reprioritized, or must stop before the next instruction. The Split Worker returns any partial result to you for review.",
       inputSchema: buildShape({}),
       handler: function (args) { return handlers.interrupt(args || {}); },
     },
     {
       name: "close_partner",
-      description: "Close the visible Worker pane and dissolve the Driver/Worker pair while preserving both session histories. If the Worker is still running, Clay interrupts it before closing the pair.",
+      description: "Close the visible Split Worker pane and dissolve the Driver/Split Worker pair while preserving both session histories. If the Split Worker is still running, Clay interrupts it before closing the pair.",
       inputSchema: buildShape({}),
       handler: function (args) { return handlers.close(args || {}); },
     },

package/lib/sessions.js

@@ -170,9 +170,15 @@ function createSessionManager(opts) {
       if (session.lastRewindUuid) metaObj.lastRewindUuid = session.lastRewindUuid;
       if (session.loop) metaObj.loop = session.loop;
       if (session.spawn) metaObj.spawn = session.spawn;
+      if (session.assignment) metaObj.assignment = session.assignment;
       if (session.handoff) metaObj.handoff = session.handoff;
       if (session.debateState) metaObj.debateState = session.debateState;
       if (session.debateSetupMode) metaObj.debateSetupMode = true;
+      if (session.homeDebatePlanning) metaObj.homeDebatePlanning = true;
+      if (session.homeDebatePhase) metaObj.homeDebatePhase = session.homeDebatePhase;
+      if (session.homeDebateInitialTopic) metaObj.homeDebateInitialTopic = session.homeDebateInitialTopic;
+      if (session.homeClayEntryRequestId) metaObj.homeClayEntryRequestId = session.homeClayEntryRequestId;
+      if (session.homeClayEntryMode) metaObj.homeClayEntryMode = session.homeClayEntryMode;
       var meta = JSON.stringify(metaObj);
       var lines = [meta];
       for (var i = 0; i < session.history.length; i++) {
@@ -283,9 +289,15 @@ function createSessionManager(opts) {
       session.effort = m.effort || null;
       if (m.loop) session.loop = m.loop;
       if (m.spawn) session.spawn = m.spawn;
+      if (m.assignment) session.assignment = m.assignment;
       if (m.handoff) session.handoff = m.handoff;
       if (m.debateState) session.debateState = m.debateState;
       if (m.debateSetupMode) session.debateSetupMode = true;
+      if (m.homeDebatePlanning) session.homeDebatePlanning = true;
+      if (m.homeDebatePhase) session.homeDebatePhase = m.homeDebatePhase;
+      if (m.homeDebateInitialTopic) session.homeDebateInitialTopic = m.homeDebateInitialTopic;
+      if (m.homeClayEntryRequestId) session.homeClayEntryRequestId = m.homeClayEntryRequestId;
+      if (m.homeClayEntryMode) session.homeClayEntryMode = m.homeClayEntryMode;
       if (m.ownerId) session.ownerId = m.ownerId;
       // Born-TUI session: PTY is gone after restart, but the cliSessionId
       // is still resumable via `claude --resume <id>`. We mark the mode
@@ -865,6 +877,7 @@ function createSessionManager(opts) {
     if (sendEach) {
       var data = JSON.stringify(obj);
       sendEach(function (ws) {
+        if (session.homeDebatePlanning === true) return;
         if (ws._clayActiveSession === session.localId && ws.readyState === 1) {
           ws.send(data);
         }
@@ -881,8 +894,8 @@ function createSessionManager(opts) {
     if (!outgoingObj._ts) outgoingObj._ts = obj._ts;
     session.history.push(obj);
     appendToSessionFile(session, obj);
-    // Per-session out-of-band subscribers (used by home-chat to mirror
-    // Clay session events into a parallel UI without joining the project's
+    // Per-session out-of-band subscribers mirror mate session events into
+    // a parallel UI without joining the project's
     // ws clients set). Subscribers receive the same obj that goes to ws
     // clients; they are responsible for any transform + dispatch.
     if (session._subscribers && session._subscribers.size > 0) {
@@ -895,6 +908,7 @@ function createSessionManager(opts) {
       var data = JSON.stringify(outgoingObj);
       var ioData = null;
       sendEach(function (ws) {
+        if (session.homeDebatePlanning === true) return;
         if (ws._clayActiveSession === session.localId) {
           if (ws.readyState === 1) ws.send(data);
         } else if (session.isProcessing && !session._ioThrottle) {
@@ -993,11 +1007,12 @@ function createSessionManager(opts) {
     activeSessionId = mostRecent.localId;
   }
 
-  function searchSessions(query) {
+  function searchSessions(query, canInclude) {
     if (!query) return [];
     var q = query.toLowerCase();
     var results = [];
     sessions.forEach(function (session) {
+      if (typeof canInclude === "function" && !canInclude(session)) return;
       var titleMatch = (session.title || "New Session").toLowerCase().indexOf(q) !== -1;
       var contentMatch = false;
       for (var i = 0; i < session.history.length; i++) {

package/lib/tool-capsule-source.js

@@ -0,0 +1,142 @@
+var fs = require("fs");
+var path = require("path");
+var crypto = require("crypto");
+
+var METADATA_FILE = ".capsule-metadata.json";
+
+function metadataPath(root) {
+  return path.join(root, METADATA_FILE);
+}
+
+function readMetadata(root) {
+  try {
+    var parsed = JSON.parse(fs.readFileSync(metadataPath(root), "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch (error) {
+    return {};
+  }
+}
+
+function writeFileAtomic(file, value) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  var temporary = file + ".tmp-" + process.pid + "-" + crypto.randomBytes(6).toString("hex");
+  try {
+    fs.writeFileSync(temporary, value, { encoding: "utf8", mode: 0o600 });
+    fs.renameSync(temporary, file);
+  } catch (error) {
+    try { fs.rmSync(temporary, { force: true }); } catch (cleanupError) {}
+    throw error;
+  }
+}
+
+function sanitizedMetadata(root, toolId) {
+  var record = readMetadata(root)[toolId];
+  return { mateEditingAllowed: !!(record && record.mateEditingAllowed === true) };
+}
+
+function setMateEditingAllowed(root, toolId, allowed) {
+  var all = readMetadata(root);
+  all[toolId] = { mateEditingAllowed: allowed === true };
+  writeFileAtomic(metadataPath(root), JSON.stringify(all, null, 2) + "\n");
+  return sanitizedMetadata(root, toolId);
+}
+
+function removeMetadata(root, toolId) {
+  var all = readMetadata(root);
+  if (!Object.prototype.hasOwnProperty.call(all, toolId)) return;
+  delete all[toolId];
+  writeFileAtomic(metadataPath(root), JSON.stringify(all, null, 2) + "\n");
+}
+
+function revisionForParts(manifestSource, uiSource, logicSource) {
+  var hash = crypto.createHash("sha256");
+  var parts = [manifestSource, uiSource, logicSource === null ? "" : logicSource];
+  for (var i = 0; i < parts.length; i++) {
+    var bytes = Buffer.from(parts[i], "utf8");
+    hash.update(String(bytes.length));
+    hash.update(":");
+    hash.update(bytes);
+  }
+  return hash.digest("hex");
+}
+
+function readSource(directory) {
+  var manifestSource = fs.readFileSync(path.join(directory, "manifest.json"), "utf8");
+  var uiSource = fs.readFileSync(path.join(directory, "ui.json"), "utf8");
+  var manifest = JSON.parse(manifestSource);
+  var uiTree = JSON.parse(uiSource);
+  var runtime = manifest.runtime || "worker";
+  var logicSource = runtime === "worker" ? fs.readFileSync(path.join(directory, "logic.js"), "utf8") : null;
+  return {
+    manifest: manifest,
+    uiTree: uiTree,
+    logicSource: logicSource,
+    logicAvailable: runtime === "worker",
+    revision: revisionForParts(manifestSource, uiSource, logicSource),
+  };
+}
+
+function replaceSourceFiles(directory, sources) {
+  var names = ["manifest.json", "ui.json", "logic.js"];
+  var transaction = crypto.randomBytes(6).toString("hex");
+  var staged = [];
+  var backups = [];
+  try {
+    for (var i = 0; i < names.length; i++) {
+      var target = path.join(directory, names[i]);
+      var stage = target + ".next-" + transaction;
+      staged.push({ target: target, stage: stage });
+      fs.writeFileSync(stage, sources[names[i]], "utf8");
+    }
+    for (var j = 0; j < staged.length; j++) {
+      var backup = staged[j].target + ".previous-" + transaction;
+      fs.renameSync(staged[j].target, backup);
+      backups.push({ target: staged[j].target, backup: backup });
+      fs.renameSync(staged[j].stage, staged[j].target);
+    }
+  } catch (error) {
+    for (var ri = backups.length - 1; ri >= 0; ri--) {
+      try {
+        fs.rmSync(backups[ri].target, { force: true });
+        fs.renameSync(backups[ri].backup, backups[ri].target);
+      } catch (rollbackError) {}
+    }
+    for (var si = 0; si < staged.length; si++) {
+      try { fs.rmSync(staged[si].stage, { force: true }); } catch (cleanupError) {}
+    }
+    throw error;
+  }
+  for (var k = 0; k < backups.length; k++) {
+    try { fs.rmSync(backups[k].backup, { force: true }); } catch (cleanupError) {}
+  }
+}
+
+function updateSource(directory, input, validators) {
+  var current = readSource(directory);
+  if (!current.logicAvailable) throw new Error("Server-managed Capsules cannot be edited.");
+  if (!input || typeof input !== "object") throw new Error("Complete Capsule source is required.");
+  if (typeof input.baseRevision !== "string" || input.baseRevision !== current.revision) {
+    throw new Error("Capsule source changed. Read the latest source and retry your update.");
+  }
+  validators.validateManifest(input.manifest, { allowServerRuntime: false });
+  validators.validateUiNode(input.uiTree);
+  if (input.manifest.id !== current.manifest.id) throw new Error("Capsule updates cannot change the Capsule ID.");
+  if ((input.manifest.runtime || "worker") !== "worker") throw new Error("Capsule updates cannot change the runtime.");
+  if (typeof input.logicSource !== "string" || !input.logicSource.trim()) throw new Error("Tool logic source is required.");
+  var manifest = Object.assign({}, input.manifest, { name: input.manifest.name.trim(), runtime: "worker" });
+  replaceSourceFiles(directory, {
+    "manifest.json": JSON.stringify(manifest, null, 2) + "\n",
+    "ui.json": JSON.stringify(input.uiTree, null, 2) + "\n",
+    "logic.js": input.logicSource,
+  });
+  return readSource(directory);
+}
+
+module.exports = {
+  METADATA_FILE: METADATA_FILE,
+  sanitizedMetadata: sanitizedMetadata,
+  setMateEditingAllowed: setMateEditingAllowed,
+  removeMetadata: removeMetadata,
+  readSource: readSource,
+  updateSource: updateSource,
+};

package/lib/tool-control-mcp-server.js

@@ -0,0 +1,126 @@
+var z;
+try { z = require("zod"); } catch (e) { z = null; }
+var toolUiSpec = require("./tool-ui-spec");
+
+function textResult(value) {
+  return { content: [{ type: "text", text: JSON.stringify(value, null, 2) }] };
+}
+
+function errorResult(error) {
+  return {
+    content: [{ type: "text", text: "Error: " + (error && error.message ? error.message : String(error)) }],
+    isError: true,
+  };
+}
+
+function run(handler) {
+  return Promise.resolve().then(handler).then(textResult).catch(errorResult);
+}
+
+function schemas() {
+  if (!z) return { list: {}, tool: {}, act: {}, set: {}, install: {}, update: {}, uninstall: {} };
+  return {
+    list: {},
+    tool: { toolId: z.string().min(1).describe("Installed capsule ID.") },
+    act: {
+      toolId: z.string().min(1),
+      actionId: z.string().min(1),
+      args: z.record(z.string(), z.any()).optional().describe("Arguments for the tool action."),
+    },
+    set: {
+      toolId: z.string().min(1),
+      controlId: z.string().min(1),
+      value: z.any().describe("New value for the named control."),
+    },
+    install: {
+      manifest: z.record(z.string(), z.any()),
+      uiTree: z.record(z.string(), z.any()),
+      logicSource: z.string().min(1),
+    },
+    update: {
+      toolId: z.string().min(1),
+      baseRevision: z.string().min(1),
+      manifest: z.record(z.string(), z.any()),
+      uiTree: z.record(z.string(), z.any()),
+      logicSource: z.string().min(1),
+    },
+    uninstall: { toolId: z.string().min(1).describe("Installed worker capsule ID to remove.") },
+  };
+}
+
+var INSTALL_DESCRIPTION = [
+  "Install a new user-owned worker capsule. Existing Capsule IDs are rejected; read source and use clay_tool_update instead. This requires user approval.",
+  "manifest: {id: lowercase-slug, name, description?: concise single-line purpose, useWhen?: concise single-line trigger, lucideIcon?, runtime:'worker', permissions?:['llm'], initialAction?, skills?: markdown detailed procedural recipe}.",
+  "New Capsules should provide description and useWhen so Mates can discover when the Capsule is useful; keep the full operating procedure in skills.",
+  toolUiSpec.authoringDescription(),
+  "logicSource must define: var tool = { initialState: {...}, actions: { name: function (state, args, api) { ... return newState; } } }. Async actions may call api.setState(nextState) to publish intermediate busy/progress UI state before returning the complete final state. An uncaught action error restores the pre-action UI state; catch errors and return an explicit final state to show inline error feedback. Actions may use api.storage.list/get/put/delete/query, api.llm.complete({system?,prompt,model?}) when manifest permissions includes llm, and api.callerId. model is only fast|standard|deep. No DOM, imports, network globals, or vendor model names.",
+].join(" ");
+
+function getToolDefs(handlers) {
+  var shape = schemas();
+  return [
+    {
+      name: "clay_tool_list",
+      description: "List installed Capsules with concise discovery metadata, runtimes, and their full detailed usage recipes.",
+      inputSchema: shape.list,
+      handler: function () { return run(function () { return handlers.list(); }); },
+    },
+    {
+      name: "clay_tool_snapshot",
+      description: "Read a capsule's current state, controls, and declarative UI.",
+      inputSchema: shape.tool,
+      handler: function (args) { return run(function () { return handlers.snapshot(args.toolId); }); },
+    },
+    {
+      name: "clay_tool_act",
+      description: "Run a named tool action through the same action path used by the human UI.",
+      inputSchema: shape.act,
+      handler: function (args) {
+        return run(function () { return handlers.act(args.toolId, args.actionId, args.args || {}); });
+      },
+    },
+    {
+      name: "clay_tool_set",
+      description: "Set an interactive control by ID through the control's normal bound action.",
+      inputSchema: shape.set,
+      handler: function (args) { return run(function () { return handlers.set(args.toolId, args.controlId, args.value); }); },
+    },
+    {
+      name: "clay_tool_source",
+      description: "Read the exact authored manifest, declarative UI, logic source, and revision for an installed worker Capsule. The user must first enable Allow Mate editing for that Capsule.",
+      inputSchema: shape.tool,
+      handler: function (args) { return run(function () { return handlers.source(args.toolId); }); },
+    },
+    {
+      name: "clay_tool_install",
+      description: INSTALL_DESCRIPTION,
+      inputSchema: shape.install,
+      handler: function (args) {
+        return run(function () { return handlers.install({ manifest: args.manifest, uiTree: args.uiTree, logicSource: args.logicSource }); });
+      },
+    },
+    {
+      name: "clay_tool_update",
+      description: "Replace the complete authored source of an existing worker Capsule after validating its current revision. This requires user approval and preserves Capsule storage.",
+      inputSchema: shape.update,
+      handler: function (args) {
+        return run(function () {
+          return handlers.update(args.toolId, {
+            baseRevision: args.baseRevision,
+            manifest: args.manifest,
+            uiTree: args.uiTree,
+            logicSource: args.logicSource,
+          });
+        });
+      },
+    },
+    {
+      name: "clay_tool_uninstall",
+      description: "Remove a user-owned capsule folder and its data. This requires user approval.",
+      inputSchema: shape.uninstall,
+      handler: function (args) { return run(function () { return handlers.uninstall(args.toolId); }); },
+    },
+  ];
+}
+
+module.exports = { INSTALL_DESCRIPTION: INSTALL_DESCRIPTION, getToolDefs: getToolDefs };

package/lib/tool-llm.js

@@ -0,0 +1,48 @@
+var MODEL_ALIASES = ["fast", "standard", "deep"];
+
+function validateArgs(args) {
+  args = args || {};
+  if (typeof args.prompt !== "string" || !args.prompt.trim()) throw new Error("LLM prompt is required.");
+  if (args.system !== undefined && typeof args.system !== "string") throw new Error("LLM system prompt must be a string.");
+  var alias = args.model || "fast";
+  if (MODEL_ALIASES.indexOf(alias) === -1) {
+    throw new Error("LLM model must be a capability alias: fast, standard, or deep. Vendor model names are not allowed.");
+  }
+  return { system: args.system || "", prompt: args.prompt, model: alias };
+}
+
+async function complete(opts) {
+  var args = validateArgs(opts.args);
+  var adapters = opts.adapters || {};
+  var selection = opts.selection || {};
+  var vendor = selection.vendor;
+  var model = selection.model;
+  if (!vendor || !model || typeof model !== "string") {
+    throw new Error(selection.error || "No configured model is available. Configure a provider and retry.");
+  }
+  var adapter = adapters[vendor];
+  if (!adapter) throw new Error("The configured " + vendor + " model provider is unavailable.");
+  var yoke = require("./yoke");
+  var result = await yoke.completeOnce(adapter, {
+    cwd: opts.cwd,
+    model: model,
+    systemPrompt: args.system || undefined,
+    prompt: args.prompt,
+    timeoutMs: opts.timeoutMs || 60000,
+    query: {
+      cwd: opts.cwd,
+      linuxUser: opts.linuxUser || undefined,
+      skipProjectInstructions: true,
+      skipSkills: true,
+      canUseTool: function () { return Promise.resolve({ behavior: "deny", message: "Capsule LLM calls cannot use tools." }); },
+      adapterOptions: { CLAUDE: { linuxUser: opts.linuxUser || undefined, settingSources: ["user"] } },
+    },
+  });
+  return result.text;
+}
+
+module.exports = {
+  MODEL_ALIASES: MODEL_ALIASES,
+  validateArgs: validateArgs,
+  complete: complete,
+};

package/lib/tool-storage.js

@@ -0,0 +1,77 @@
+var fs = require("fs");
+var path = require("path");
+var Datastore = require("@seald-io/nedb");
+var toolsRegistry = require("./tools-registry");
+
+var MAX_DOCUMENT_BYTES = 64 * 1024;
+var datastoresByFile = {};
+
+function createToolStorage(ctx, toolId) {
+  toolsRegistry.validateToolId(toolId);
+  var directory = path.join(toolsRegistry.resolveToolsRoot(ctx), toolId);
+  var filename = path.join(directory, "data.db");
+
+  function getDatastore() {
+    if (!datastoresByFile[filename]) {
+      fs.mkdirSync(directory, { recursive: true });
+      datastoresByFile[filename] = new Datastore({ filename: filename, autoload: true });
+    }
+    return datastoresByFile[filename];
+  }
+
+  async function ready() {
+    var datastore = getDatastore();
+    await datastore.autoloadPromise;
+    return datastore;
+  }
+
+  function validateDocument(doc) {
+    if (!doc || typeof doc !== "object" || Array.isArray(doc)) throw new Error("Storage document must be an object.");
+    var bytes = Buffer.byteLength(JSON.stringify(doc), "utf8");
+    if (bytes > MAX_DOCUMENT_BYTES) throw new Error("Storage document exceeds the 64KB limit.");
+  }
+
+  async function list() {
+    var datastore = await ready();
+    return datastore.findAsync({});
+  }
+
+  async function get(id) {
+    if (typeof id !== "string" || !id) throw new Error("Storage document ID is required.");
+    var datastore = await ready();
+    return datastore.findOneAsync({ _id: id });
+  }
+
+  async function put(doc) {
+    validateDocument(doc);
+    var datastore = await ready();
+    if (!doc._id) return datastore.insertAsync(doc);
+    var changes = {};
+    var keys = Object.keys(doc);
+    for (var i = 0; i < keys.length; i++) {
+      if (keys[i] !== "_id") changes[keys[i]] = doc[keys[i]];
+    }
+    var result = await datastore.updateAsync(
+      { _id: doc._id },
+      { $set: changes },
+      { upsert: true, returnUpdatedDocs: true }
+    );
+    return result.affectedDocuments;
+  }
+
+  async function remove(id) {
+    if (typeof id !== "string" || !id) throw new Error("Storage document ID is required.");
+    var datastore = await ready();
+    return datastore.removeAsync({ _id: id }, {});
+  }
+
+  async function query(selector) {
+    if (!selector || typeof selector !== "object" || Array.isArray(selector)) throw new Error("Storage query must be an object.");
+    var datastore = await ready();
+    return datastore.findAsync(selector);
+  }
+
+  return { list: list, get: get, put: put, delete: remove, query: query };
+}
+
+module.exports = { MAX_DOCUMENT_BYTES: MAX_DOCUMENT_BYTES, createToolStorage: createToolStorage };

package/lib/tool-ui-spec-advanced.js

@@ -0,0 +1,82 @@
+var CONDITION_OPS = ["all", "any", "not", "equals", "notEquals", "in", "gt", "gte", "lt", "lte"];
+var MAX_CONDITIONS = 40;
+
+function isPlainObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  var prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+function isSafePath(value) {
+  if (typeof value !== "string" || !/^(?:\$(?:state|item)\.)?[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*$/.test(value)) return false;
+  var parts = value.replace(/^\$(?:state|item)\./, "").split(".");
+  return !parts.some(function (part) { return part === "__proto__" || part === "constructor" || part === "prototype"; });
+}
+
+function safeScalar(value) {
+  return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+
+function validateDynamic(value, rule, location, validateRule) {
+  if (!isPlainObject(value) || !Object.prototype.hasOwnProperty.call(value, "$bind")) return false;
+  var dynamicAllowed = rule === "text" || rule === "bindingBoolean" || rule === "number" || rule === "positiveNumber" || rule === "options" || rule === "columns" || rule === "scalar" || !!(rule && rule.integer) || Array.isArray(rule);
+  if (!dynamicAllowed) throw new Error(location + " does not allow a dynamic value.");
+  var keys = Object.keys(value);
+  if (keys.some(function (key) { return key !== "$bind" && key !== "fallback" && key !== "$enum"; }) || !isSafePath(value.$bind)) throw new Error(location + " dynamic value requires a safe $bind and optional fallback.");
+  if (Array.isArray(rule)) {
+    if (!Array.isArray(value.$enum) || !value.$enum.length || value.$enum.length > rule.length || value.$enum.some(function (entry) { return rule.indexOf(entry) === -1; })) throw new Error(location + ".$enum must contain only allowed enum values.");
+  } else if (value.$enum !== undefined) throw new Error(location + ".$enum is only valid for enum properties.");
+  if (value.fallback !== undefined) validateRule(value.fallback, rule, location + ".fallback");
+  return true;
+}
+
+function validateCondition(condition, location, context) {
+  context = context || { count: 0 };
+  context.count++;
+  if (context.count > MAX_CONDITIONS) throw new Error(location + " exceeds " + MAX_CONDITIONS + " condition terms.");
+  if (typeof condition === "string") {
+    if (!isSafePath(condition)) throw new Error(location + " must be a safe state path or condition object.");
+    return;
+  }
+  if (!isPlainObject(condition)) throw new Error(location + " must be a safe state path or condition object.");
+  var keys = Object.keys(condition);
+  if (keys.length !== 1 || CONDITION_OPS.indexOf(keys[0]) === -1) throw new Error(location + " must contain exactly one allowed condition operator.");
+  var op = keys[0];
+  var value = condition[op];
+  if (op === "all" || op === "any") {
+    if (!Array.isArray(value) || value.length < 1 || value.length > 12) throw new Error(location + "." + op + " must contain 1 to 12 conditions.");
+    for (var i = 0; i < value.length; i++) validateCondition(value[i], location + "." + op + "[" + i + "]", context);
+    return;
+  }
+  if (op === "not") {
+    validateCondition(value, location + ".not", context);
+    return;
+  }
+  if (!isPlainObject(value) || !isSafePath(value.path)) throw new Error(location + "." + op + " requires a safe path.");
+  var allowed = op === "in" ? ["path", "values"] : ["path", "value"];
+  if (Object.keys(value).some(function (key) { return allowed.indexOf(key) === -1; })) throw new Error(location + "." + op + " contains an unknown property.");
+  if (op === "in") {
+    if (!Array.isArray(value.values) || value.values.length < 1 || value.values.length > 50 || value.values.some(function (entry) { return !safeScalar(entry); })) throw new Error(location + ".in values must be 1 to 50 safe scalars.");
+  } else if ((op === "gt" || op === "gte" || op === "lt" || op === "lte") && (typeof value.value !== "number" || !Number.isFinite(value.value))) {
+    throw new Error(location + "." + op + " value must be finite numeric data.");
+  } else if (op !== "in" && !safeScalar(value.value)) {
+    throw new Error(location + "." + op + " value must be scalar.");
+  }
+}
+
+function validateValidation(value, location) {
+  if (!isPlainObject(value)) throw new Error(location + " must be a validation object.");
+  var allowed = ["minLength", "maxLength", "min", "max", "step", "pattern", "message"];
+  var keys = Object.keys(value);
+  for (var i = 0; i < keys.length; i++) if (allowed.indexOf(keys[i]) === -1) throw new Error(location + " contains unknown validation rule '" + keys[i] + "'.");
+  if (value.minLength !== undefined && (!Number.isInteger(value.minLength) || value.minLength < 0 || value.minLength > 10000)) throw new Error(location + ".minLength is out of bounds.");
+  if (value.maxLength !== undefined && (!Number.isInteger(value.maxLength) || value.maxLength < 1 || value.maxLength > 10000)) throw new Error(location + ".maxLength is out of bounds.");
+  if (value.minLength !== undefined && value.maxLength !== undefined && value.minLength > value.maxLength) throw new Error(location + " minLength exceeds maxLength.");
+  var numeric = ["min", "max", "step"];
+  for (var ni = 0; ni < numeric.length; ni++) if (value[numeric[ni]] !== undefined && (typeof value[numeric[ni]] !== "number" || !Number.isFinite(value[numeric[ni]]))) throw new Error(location + "." + numeric[ni] + " must be finite numeric data.");
+  if (value.step !== undefined && value.step <= 0) throw new Error(location + ".step must be positive.");
+  if (value.pattern !== undefined && ["email", "url", "integer", "decimal"].indexOf(value.pattern) === -1) throw new Error(location + ".pattern is not allowed.");
+  if (value.message !== undefined && (typeof value.message !== "string" || value.message.length > 300)) throw new Error(location + ".message must be short text.");
+}
+
+module.exports = { validateDynamic: validateDynamic, validateCondition: validateCondition, validateValidation: validateValidation };