@kontourai/flow-agents 3.11.0 → 3.12.1

package/dist/base/build/src/flow-kit/action-metadata.js

@@ -0,0 +1,162 @@
+import * as path from "node:path";
+import { PUBLIC_OPERATION_IDS } from "../cli/public-contracts.js";
+const MAX_FLOW_STEP_ACTIONS = 128;
+const MAX_FLOW_STEP_ACTION_LIST_ITEMS = 32;
+const MAX_FLOW_STEP_ACTION_SKILLS = 16;
+const MAX_FLOW_OBSERVABLE_ARTIFACTS = 128;
+const MAX_FLOW_STEP_ACTION_TEXT = 1024;
+const WORKFLOW_TRIGGER_IDENTIFIER_RE = /^[a-z0-9]+(?:[.-][a-z0-9]+)*$/;
+export function workflowTriggerIdentifier(value) {
+    return typeof value === "string" && WORKFLOW_TRIGGER_IDENTIFIER_RE.test(value);
+}
+export function parseKitFlowStepActions(manifest, manifestPath) {
+    const entries = [];
+    const errors = [];
+    const raw = manifest.flow_step_actions;
+    if (raw === undefined)
+        return { entries, errors };
+    if (!Array.isArray(raw))
+        return { entries, errors: [`${manifestPath}: .flow_step_actions must be a list`] };
+    if (raw.length > MAX_FLOW_STEP_ACTIONS)
+        return { entries, errors: [`${manifestPath}: .flow_step_actions exceeds ${MAX_FLOW_STEP_ACTIONS} entries`] };
+    const seen = new Set();
+    raw.forEach((rawEntry, index) => {
+        const entry = parseFlowStepActionEntry(rawEntry, manifestPath, index, errors);
+        if (!entry)
+            return;
+        const key = `${entry.flow_id}/${entry.step_id}`;
+        if (seen.has(key))
+            errors.push(`${manifestPath}: flow_step_actions[${index}] duplicates '${key}'`);
+        else {
+            seen.add(key);
+            entries.push(entry);
+        }
+    });
+    validateObservableArtifactBounds(entries, manifestPath, errors);
+    return { entries, errors };
+}
+function parseFlowStepActionEntry(raw, manifestPath, index, errors) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        errors.push(`${manifestPath}: flow_step_actions[${index}] must be an object`);
+        return null;
+    }
+    const record = raw;
+    const supported = new Set(["flow_id", "step_id", "skills", "operations", "expectation_ids", "artifacts", "implementation_allowed", "expectation_bindings", "artifact_bindings"]);
+    const unsupported = Object.keys(record).filter((key) => !supported.has(key));
+    if (unsupported.length) {
+        errors.push(`${manifestPath}: flow_step_actions[${index}] has unsupported field(s): ${unsupported.join(", ")}`);
+        return null;
+    }
+    if (!workflowTriggerIdentifier(record.flow_id) || !workflowTriggerIdentifier(record.step_id)) {
+        errors.push(`${manifestPath}: flow_step_actions[${index}] must declare valid flow_id and step_id identifiers`);
+        return null;
+    }
+    for (const field of ["expectation_ids", "artifacts", "implementation_allowed", "expectation_bindings", "artifact_bindings"]) {
+        if (!Object.hasOwn(record, field))
+            errors.push(`${manifestPath}: flow_step_actions[${index}].${field} must be explicitly declared`);
+    }
+    const lists = parseFlowStepActionLists(record, manifestPath, index, errors);
+    if (!lists || typeof record.implementation_allowed !== "boolean") {
+        if (typeof record.implementation_allowed !== "boolean")
+            errors.push(`${manifestPath}: flow_step_actions[${index}].implementation_allowed must be a boolean`);
+        return null;
+    }
+    const expectationBindings = parseExpectationBindings(record.expectation_bindings ?? [], lists.operations, manifestPath, index, errors);
+    if (!expectationBindings || !sameStringSet(expectationBindings.map((binding) => binding.expectation_id), lists.expectation_ids)) {
+        if (expectationBindings)
+            errors.push(`${manifestPath}: flow_step_actions[${index}].expectation_bindings must bind every expectation_id exactly once`);
+        return null;
+    }
+    const artifactBindings = parseArtifactBindings(record.artifact_bindings ?? [], lists.artifacts, lists.expectation_ids, manifestPath, index, errors);
+    return artifactBindings ? { flow_id: record.flow_id, step_id: record.step_id, ...lists, implementation_allowed: record.implementation_allowed, expectation_bindings: expectationBindings, artifact_bindings: artifactBindings } : null;
+}
+function parseFlowStepActionLists(record, manifestPath, index, errors) {
+    const skills = record.skills;
+    const operations = record.operations ?? [];
+    const expectationIds = record.expectation_ids ?? [];
+    const artifacts = record.artifacts ?? [];
+    const label = `${manifestPath}: flow_step_actions[${index}]`;
+    if ([skills, operations, expectationIds, artifacts].some((list) => Array.isArray(list) && list.length > MAX_FLOW_STEP_ACTION_LIST_ITEMS))
+        return fail(errors, `${label} list exceeds ${MAX_FLOW_STEP_ACTION_LIST_ITEMS} entries`);
+    if (!Array.isArray(skills) || !skills.every(workflowTriggerIdentifier) || new Set(skills).size !== skills.length)
+        return fail(errors, `${label}.skills must be an identifier list without duplicates`);
+    if (skills.length > MAX_FLOW_STEP_ACTION_SKILLS)
+        return fail(errors, `${label}.skills exceeds ${MAX_FLOW_STEP_ACTION_SKILLS} entries`);
+    if (!Array.isArray(operations) || !operations.every(workflowTriggerIdentifier) || new Set(operations).size !== operations.length || operations.some((operation) => !PUBLIC_OPERATION_IDS.has(operation)))
+        return fail(errors, `${label}.operations must be unique identifiers from the canonical public operation catalog`);
+    if (!Array.isArray(expectationIds) || !expectationIds.every(workflowTriggerIdentifier) || new Set(expectationIds).size !== expectationIds.length)
+        return fail(errors, `${label}.expectation_ids must be a unique identifier list`);
+    if (!Array.isArray(artifacts) || !artifacts.every(isSafeBuilderArtifactRef) || new Set(artifacts).size !== artifacts.length)
+        return fail(errors, `${label}.artifacts must be unique safe session-relative paths or trust.bundle#<safe-id> refs`);
+    if ([...skills, ...operations, ...expectationIds, ...artifacts].some((entry) => entry.length > MAX_FLOW_STEP_ACTION_TEXT))
+        return fail(errors, `${label} values must not exceed ${MAX_FLOW_STEP_ACTION_TEXT} characters`);
+    return { skills, operations, expectation_ids: expectationIds, artifacts };
+}
+function fail(errors, message) { errors.push(message); return null; }
+function validateObservableArtifactBounds(entries, manifestPath, errors) {
+    const observableByFlow = new Map();
+    for (const action of entries) {
+        const observed = observableByFlow.get(action.flow_id) ?? new Set();
+        for (const artifact of action.artifacts)
+            if (isObservableBuilderArtifactRef(artifact))
+                observed.add(artifact);
+        observableByFlow.set(action.flow_id, observed);
+    }
+    for (const [flowId, artifacts] of observableByFlow)
+        if (artifacts.size > MAX_FLOW_OBSERVABLE_ARTIFACTS)
+            errors.push(`${manifestPath}: flow_step_actions for '${flowId}' exceed ${MAX_FLOW_OBSERVABLE_ARTIFACTS} distinct observable file artifacts`);
+}
+function parseExpectationBindings(value, operations, manifestPath, actionIndex, errors) {
+    if (!Array.isArray(value) || value.length > MAX_FLOW_STEP_ACTION_LIST_ITEMS)
+        return fail(errors, `${manifestPath}: flow_step_actions[${actionIndex}].expectation_bindings must be a bounded list`);
+    const bindings = [];
+    for (const [bindingIndex, entry] of value.entries()) {
+        if (typeof entry !== "object" || entry === null || Array.isArray(entry))
+            return fail(errors, `${manifestPath}: flow_step_actions[${actionIndex}].expectation_bindings[${bindingIndex}] must be an object`);
+        const record = entry;
+        const unsupported = Object.keys(record).filter((key) => key !== "expectation_id" && key !== "interface" && key !== "operation");
+        if (unsupported.length)
+            return fail(errors, `${manifestPath}: flow_step_actions[${actionIndex}].expectation_bindings[${bindingIndex}] has unsupported field(s): ${unsupported.join(", ")}`);
+        if (!workflowTriggerIdentifier(record.expectation_id) || !new Set(["workflow.evidence", "workflow.critique", "operation"]).has(String(record.interface)))
+            return fail(errors, `${manifestPath}: flow_step_actions[${actionIndex}].expectation_bindings[${bindingIndex}] must declare a valid expectation_id and interface`);
+        if (record.interface === "operation") {
+            if (!workflowTriggerIdentifier(record.operation) || !operations.includes(record.operation) || !PUBLIC_OPERATION_IDS.has(record.operation))
+                return fail(errors, `${manifestPath}: flow_step_actions[${actionIndex}].expectation_bindings[${bindingIndex}].operation must name a declared canonical public operation`);
+        }
+        else if (record.operation !== undefined)
+            return fail(errors, `${manifestPath}: flow_step_actions[${actionIndex}].expectation_bindings[${bindingIndex}].operation is allowed only for operation bindings`);
+        bindings.push({ expectation_id: record.expectation_id, interface: record.interface, ...(typeof record.operation === "string" ? { operation: record.operation } : {}) });
+    }
+    if (new Set(bindings.map((binding) => binding.expectation_id)).size !== bindings.length)
+        return fail(errors, `${manifestPath}: flow_step_actions[${actionIndex}].expectation_bindings must not duplicate expectation ids`);
+    return bindings;
+}
+function parseArtifactBindings(value, artifacts, expectationIds, manifestPath, actionIndex, errors) {
+    if (!Array.isArray(value) || value.length > MAX_FLOW_STEP_ACTION_LIST_ITEMS)
+        return fail(errors, `${manifestPath}: flow_step_actions[${actionIndex}].artifact_bindings must be a bounded list`);
+    const bindings = [];
+    for (const [bindingIndex, entry] of value.entries()) {
+        if (typeof entry !== "object" || entry === null || Array.isArray(entry))
+            return fail(errors, `${manifestPath}: flow_step_actions[${actionIndex}].artifact_bindings[${bindingIndex}] must be an object`);
+        const record = entry;
+        if (Object.keys(record).some((key) => key !== "artifact" && key !== "expectation_ids") || typeof record.artifact !== "string" || !artifacts.includes(record.artifact)
+            || !Array.isArray(record.expectation_ids) || !record.expectation_ids.every((id) => typeof id === "string" && expectationIds.includes(id)) || new Set(record.expectation_ids).size !== record.expectation_ids.length)
+            return fail(errors, `${manifestPath}: flow_step_actions[${actionIndex}].artifact_bindings[${bindingIndex}] must bind one declared artifact to declared expectation_ids`);
+        bindings.push({ artifact: record.artifact, expectation_ids: record.expectation_ids });
+    }
+    if (!sameStringSet(bindings.map((binding) => binding.artifact), artifacts))
+        return fail(errors, `${manifestPath}: flow_step_actions[${actionIndex}].artifact_bindings must bind every artifact exactly once`);
+    return bindings;
+}
+export function isSafeBuilderArtifactRef(value) {
+    if (typeof value !== "string" || value.length === 0 || value.includes("\0") || value.includes("\\"))
+        return false;
+    if (value.startsWith("trust.bundle#"))
+        return /^trust\.bundle#[a-z0-9]+(?:[.-][a-z0-9]+)*$/.test(value);
+    if (value.includes("#") || path.posix.isAbsolute(value))
+        return false;
+    const expanded = value.replaceAll("<slug>", "slug");
+    return expanded !== "." && !expanded.split("/").some((part) => part === "" || part === "." || part === "..");
+}
+export function isObservableBuilderArtifactRef(value) { return !value.includes("#") && path.posix.normalize(value) !== "state.json"; }
+export function sameStringSet(left, right) { return left.length === right.length && new Set(left).size === left.length && left.every((entry) => right.includes(entry)); }

package/dist/base/build/src/flow-kit/action-repository-validation.d.ts

@@ -0,0 +1,16 @@
+import { type KitFlowStepActionEntry } from "./action-metadata.js";
+type SkillRoleEntry = {
+    skill_id: string;
+    role: string;
+    flow_id?: string;
+    step_ids: string[];
+    expectation_ids: string[];
+};
+export declare function validateActionRepositoryMetadata(input: {
+    kitDir: string;
+    manifestPath: string;
+    manifest: Record<string, unknown>;
+    actions: KitFlowStepActionEntry[];
+    skillRoles: SkillRoleEntry[];
+}): string[];
+export {};

package/dist/base/build/src/flow-kit/action-repository-validation.js

@@ -0,0 +1,237 @@
+import fs from "node:fs";
+import * as path from "node:path";
+import { sameStringSet } from "./action-metadata.js";
+const MAX_FLOW_DEFINITION_BYTES = 1_048_576;
+export function validateActionRepositoryMetadata(input) {
+    const errors = [];
+    validateDeclaredSkills(input.manifest, input.skillRoles, input.manifestPath, errors);
+    const flows = loadFlowMetadata(input.kitDir, input.manifest, input.manifestPath, errors);
+    const resolve = effectiveStepResolver(flows);
+    validateRoleReferences(input.skillRoles, flows, resolve, input.manifestPath, errors);
+    const owners = seedSkillOwners(input.skillRoles, resolve);
+    validateActions(input.actions, input.skillRoles, flows, resolve, owners, input.manifest, input.manifestPath, errors);
+    validateOwnerCardinality(flows, owners, input.manifestPath, errors);
+    return errors;
+}
+function validateDeclaredSkills(manifest, roles, manifestPath, errors) {
+    const declared = new Set(Array.isArray(manifest.skills) ? manifest.skills.flatMap((entry) => typeof entry === "object" && entry !== null && typeof entry.id === "string" ? [entry.id] : []) : []);
+    const bound = new Set(roles.map((entry) => entry.skill_id));
+    for (const id of declared)
+        if (!bound.has(id))
+            errors.push(`${manifestPath}: skill_roles is missing declared skill '${id}'`);
+    for (const id of bound)
+        if (!declared.has(id))
+            errors.push(`${manifestPath}: skill_roles references undeclared skill '${id}'`);
+}
+function loadFlowMetadata(kitDir, manifest, manifestPath, errors) {
+    const flows = new Map();
+    if (!Array.isArray(manifest.flows))
+        return flows;
+    for (const entry of manifest.flows) {
+        if (typeof entry !== "object" || entry === null)
+            continue;
+        const flow = entry;
+        if (typeof flow.id !== "string" || typeof flow.path !== "string")
+            continue;
+        const safe = readSafeFlowDefinition(kitDir, flow.path);
+        if (!safe.definition) {
+            errors.push(`${manifestPath}: flows '${flow.id}' ${safe.error}`);
+            continue;
+        }
+        const definition = safe.definition;
+        const steps = Array.isArray(definition.steps) ? definition.steps.filter(isRecord) : [];
+        const stepIds = new Set(steps.flatMap((step) => typeof step.id === "string" ? [step.id] : []));
+        const usesFlowByStep = new Map(steps.flatMap((step) => typeof step.id === "string" && typeof step.uses_flow === "string" ? [[step.id, step.uses_flow]] : []));
+        flows.set(flow.id, { steps: stepIds, usesFlowByStep, expectationsByStep: expectationsByStep(definition), exports: new Set(Array.isArray(definition.exports) ? definition.exports.filter((value) => typeof value === "string" && value.length > 0) : []) });
+    }
+    return flows;
+}
+function expectationsByStep(definition) {
+    const result = new Map();
+    if (!isRecord(definition.gates))
+        return result;
+    for (const gate of Object.values(definition.gates)) {
+        if (!isRecord(gate) || typeof gate.step !== "string" || !Array.isArray(gate.expects))
+            continue;
+        const expectations = result.get(gate.step) ?? new Map();
+        for (const value of gate.expects) {
+            if (!isRecord(value) || typeof value.id !== "string")
+                continue;
+            const exportKeys = new Set([value.id]);
+            if (isRecord(value.bundle_claim) && typeof value.bundle_claim.claimType === "string")
+                exportKeys.add(value.bundle_claim.claimType);
+            expectations.set(value.id, { id: value.id, exportKeys });
+        }
+        result.set(gate.step, expectations);
+    }
+    return result;
+}
+function effectiveStepResolver(flows) {
+    const resolve = (flowId, stepId, seen = new Set()) => {
+        const cycleKey = `${flowId}\0${stepId}`;
+        if (seen.has(cycleKey))
+            return undefined;
+        seen.add(cycleKey);
+        const flow = flows.get(flowId);
+        if (!flow)
+            return undefined;
+        const direct = flow.expectationsByStep.get(stepId);
+        if (direct)
+            return { sourceFlowId: flowId, stepId, expectations: direct, flowIds: new Set([flowId]) };
+        const childFlowId = flow.usesFlowByStep.get(stepId);
+        if (!childFlowId)
+            return { sourceFlowId: flowId, stepId, expectations: new Map(), flowIds: new Set([flowId]) };
+        const child = resolve(childFlowId, stepId, seen);
+        const childFlow = flows.get(childFlowId);
+        if (!child || !childFlow || [...child.expectations.values()].some((expectation) => ![...expectation.exportKeys].some((key) => childFlow.exports.has(key))))
+            return undefined;
+        child.flowIds.add(flowId);
+        return child;
+    };
+    return resolve;
+}
+function validateRoleReferences(roles, flows, resolve, manifestPath, errors) {
+    for (const row of roles) {
+        if (!row.flow_id)
+            continue;
+        const flow = flows.get(row.flow_id);
+        if (!flow) {
+            errors.push(`${manifestPath}: skill_roles '${row.skill_id}' references unknown flow '${row.flow_id}'`);
+            continue;
+        }
+        for (const stepId of row.step_ids)
+            if (!flow.steps.has(stepId))
+                errors.push(`${manifestPath}: skill_roles '${row.skill_id}' references unknown step '${row.flow_id}/${stepId}'`);
+        const allowed = new Set(row.step_ids.flatMap((stepId) => [...(resolve(row.flow_id, stepId)?.expectations.keys() ?? [])]));
+        for (const expectationId of row.expectation_ids)
+            if (!allowed.has(expectationId))
+                errors.push(`${manifestPath}: skill_roles '${row.skill_id}' expectation '${expectationId}' is not owned by its bound step(s)`);
+    }
+}
+function seedSkillOwners(roles, resolve) {
+    const owners = new Map();
+    for (const row of roles) {
+        if (row.role !== "step" || !row.flow_id)
+            continue;
+        for (const stepId of row.step_ids) {
+            const effective = resolve(row.flow_id, stepId);
+            if (!effective)
+                continue;
+            for (const expectationId of row.expectation_ids)
+                if (effective.expectations.has(expectationId)) {
+                    const key = `${effective.sourceFlowId}\0${effective.stepId}\0${expectationId}`;
+                    owners.set(key, [...(owners.get(key) ?? []), `skill:${row.skill_id}`]);
+                }
+        }
+    }
+    return owners;
+}
+function validateActions(actions, roles, flows, resolve, owners, manifest, manifestPath, errors) {
+    const roleByShortId = new Map(roles.map((entry) => [entry.skill_id.replace(`${String(manifest.id)}.`, ""), entry]));
+    for (const action of actions) {
+        const flow = flows.get(action.flow_id);
+        if (!flow || !flow.steps.has(action.step_id)) {
+            errors.push(`${manifestPath}: flow_step_actions '${action.flow_id}/${action.step_id}' references an unknown flow step`);
+            continue;
+        }
+        const effective = resolve(action.flow_id, action.step_id);
+        if (!effective) {
+            errors.push(`${manifestPath}: flow_step_actions '${action.flow_id}/${action.step_id}' cannot resolve its composed Flow step`);
+            continue;
+        }
+        for (const id of action.expectation_ids)
+            if (!effective.expectations.has(id))
+                errors.push(`${manifestPath}: flow_step_actions '${action.flow_id}/${action.step_id}' operation expectation '${id}' is not owned by its resolved Flow step`);
+        if (!sameStringSet(action.expectation_ids, [...effective.expectations.keys()]))
+            errors.push(`${manifestPath}: flow_step_actions '${action.flow_id}/${action.step_id}' expectation_ids must exactly equal its resolved Flow expectation set`);
+        for (const skill of action.skills) {
+            const row = roleByShortId.get(skill);
+            if (!row || row.role !== "step" || !row.flow_id || !effective.flowIds.has(row.flow_id) || !row.step_ids.includes(action.step_id))
+                errors.push(`${manifestPath}: flow_step_actions '${action.flow_id}/${action.step_id}' skill '${skill}' must match one step-role binding`);
+        }
+        for (const expectationId of effective.expectations.keys()) {
+            const binding = action.expectation_bindings.find((entry) => entry.expectation_id === expectationId);
+            if (binding?.interface !== "operation")
+                continue;
+            const key = `${effective.sourceFlowId}\0${effective.stepId}\0${expectationId}`;
+            owners.set(key, [...(owners.get(key) ?? []), `operation:${action.flow_id}/${action.step_id}`]);
+        }
+    }
+}
+function validateOwnerCardinality(flows, owners, manifestPath, errors) {
+    for (const [flowId, flow] of flows)
+        for (const [stepId, expectations] of flow.expectationsByStep)
+            for (const expectationId of expectations.keys()) {
+                const found = owners.get(`${flowId}\0${stepId}\0${expectationId}`) ?? [];
+                if (found.length !== 1)
+                    errors.push(`${manifestPath}: flow expectation '${flowId}/${stepId}/${expectationId}' must have exactly one producer owner; found ${found.length}`);
+            }
+}
+function readSafeFlowDefinition(kitDir, relativePath) {
+    const root = path.resolve(kitDir);
+    if (path.isAbsolute(relativePath))
+        return { error: "path must be relative" };
+    const lexical = path.resolve(root, relativePath);
+    if (lexical === root || !lexical.startsWith(`${root}${path.sep}`))
+        return { error: "path must stay inside the kit directory" };
+    let fd;
+    try {
+        const realRoot = fs.realpathSync(root);
+        const initial = lstatSafePath(realRoot, relativePath);
+        if (!initial.file || !initial.stat)
+            return { error: initial.error };
+        if (!initial.stat.isFile())
+            return { error: "path must reference a regular file" };
+        if (initial.stat.size > MAX_FLOW_DEFINITION_BYTES)
+            return { error: `file exceeds ${MAX_FLOW_DEFINITION_BYTES} bytes` };
+        if (typeof fs.constants.O_NOFOLLOW !== "number")
+            return { error: "O_NOFOLLOW is unavailable" };
+        fd = fs.openSync(initial.file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+        const opened = fs.fstatSync(fd);
+        if (!opened.isFile() || !sameIdentity(initial.stat, opened))
+            return { error: "flow definition identity changed while opening" };
+        const verified = lstatSafePath(realRoot, relativePath);
+        if (!verified.stat || !sameIdentity(opened, verified.stat))
+            return { error: "flow definition identity changed while opening" };
+        const bytes = Buffer.alloc(opened.size);
+        let offset = 0;
+        while (offset < bytes.length) {
+            const read = fs.readSync(fd, bytes, offset, bytes.length - offset, offset);
+            if (read === 0)
+                break;
+            offset += read;
+        }
+        const after = fs.fstatSync(fd);
+        if (offset !== opened.size || after.size !== opened.size || !sameIdentity(opened, after))
+            return { error: "file changed while being read" };
+        return { definition: JSON.parse(bytes.toString("utf8")) };
+    }
+    catch (error) {
+        if (error.code === "ELOOP")
+            return { error: "path must not reference a symbolic link" };
+        return { error: `path is not readable: ${error.message}` };
+    }
+    finally {
+        if (fd !== undefined)
+            fs.closeSync(fd);
+    }
+}
+function lstatSafePath(root, relativePath) {
+    const parts = relativePath.split(path.sep);
+    let current = root;
+    for (const [index, part] of parts.entries()) {
+        if (!part || part === "." || part === "..")
+            return { error: "path must stay inside the kit directory" };
+        current = path.join(current, part);
+        const stat = fs.lstatSync(current);
+        if (stat.isSymbolicLink())
+            return { error: "path must not traverse a symbolic link" };
+        if (index < parts.length - 1 && !stat.isDirectory())
+            return { error: "path component must be a directory" };
+        if (index === parts.length - 1)
+            return { file: current, stat };
+    }
+    return { error: "path must reference a regular file" };
+}
+function sameIdentity(left, right) { return left.dev === right.dev && left.ino === right.ino; }
+function isRecord(value) { return typeof value === "object" && value !== null && !Array.isArray(value); }

package/dist/base/build/src/flow-kit/validate.d.ts

@@ -1,3 +1,5 @@
+export { isObservableBuilderArtifactRef, isSafeBuilderArtifactRef, parseKitFlowStepActions } from "./action-metadata.js";
+export type { KitFlowStepActionEntry, KitFlowStepArtifactBinding, KitFlowStepExpectationBinding } from "./action-metadata.js";
 export interface KitDependencyEntry {
     kit_id: string;
     reason?: string;
@@ -23,16 +25,6 @@ export interface KitHookInfluenceExpectationEntry {
     must_include_guidance: string[];
     must_include_actions: string[];
 }
-export interface KitFlowStepActionEntry {
-    flow_id: string;
-    step_id: string;
-    skills: string[];
-    operations: string[];
-    /** Gate expectations produced by this action's explicit operation(s). */
-    expectation_ids?: string[];
-    /** Durable artifacts produced by an operation-only action. */
-    artifacts: string[];
-}
 export type KitSkillRole = "entrypoint" | "profile" | "step" | "shared-primitive" | "extension";
 export interface KitSkillRoleEntry {
     skill_id: string;
@@ -69,10 +61,6 @@ export declare function parseKitHookInfluenceExpectations(manifest: Record<strin
     entries: KitHookInfluenceExpectationEntry[];
     errors: string[];
 };
-export declare function parseKitFlowStepActions(manifest: Record<string, unknown>, manifestPath: string): {
-    entries: KitFlowStepActionEntry[];
-    errors: string[];
-};
 export declare function parseKitSkillRoles(manifest: Record<string, unknown>, manifestPath: string): {
     entries: KitSkillRoleEntry[];
     errors: string[];