agent-inspect 6.30.0 → 6.31.1

package/packages/core/dist/advanced.d.cts

@@ -6,8 +6,8 @@ import { a as InspectRunTree } from './inspect-event-ClM5Z8om.cjs';
 export { b as ATTRIBUTION_CONFIDENCES, c as ATTRIBUTION_CONFIDENCE_RANK, A as AttributionConfidence, E as EventSource, d as InspectEvent, I as InspectKind, e as InspectNode, i as isAttributionConfidence } from './inspect-event-ClM5Z8om.cjs';
 import { P as PersistedInspectEvent } from './persisted-inspect-event-q2ViiBW6.cjs';
 import { Stats } from 'node:fs';
-import { aR as SessionWorkflowMetadata, aS as SessionRunRecord, aT as EnrichSessionSummaryOptions, aU as SessionStatus, aV as SessionSummary, aW as SessionIndex, aX as BuildActivitySummaryOptions, aY as ActivitySummary, aZ as SessionWarning, a_ as BuildSessionIndexOptions, N as TraceCheckResult, X as TraceCheckStatus, a2 as TraceContractInput, Z as TraceContract } from './index-CQJUNPPe.cjs';
-export { a$ as ActivityEntry, b0 as CriticalPathStep, b1 as HandoffEdge, b2 as RetryLink, b3 as SESSION_WORKFLOW_KEYS, b4 as SessionCheckSummary, b5 as SessionConfidence, b6 as SessionEdgeSource, b7 as SessionGroup, b8 as SessionLastError, b9 as SessionWorkflowKey } from './index-CQJUNPPe.cjs';
+import { aZ as SessionWorkflowMetadata, a_ as SessionRunRecord, a$ as EnrichSessionSummaryOptions, b0 as SessionStatus, b1 as SessionSummary, b2 as SessionIndex, b3 as BuildActivitySummaryOptions, b4 as ActivitySummary, b5 as SessionWarning, b6 as BuildSessionIndexOptions, U as TraceCheckResult, _ as TraceCheckStatus, a5 as TraceContractInput, a0 as TraceContract } from './index-EQihlEei.cjs';
+export { b7 as ActivityEntry, b8 as CriticalPathStep, b9 as HandoffEdge, ba as RetryLink, bb as SESSION_WORKFLOW_KEYS, bc as SessionCheckSummary, bd as SessionConfidence, be as SessionEdgeSource, bf as SessionGroup, bg as SessionLastError, bh as SessionWorkflowKey } from './index-EQihlEei.cjs';
 import { b as ObservedOutcome } from './types-BA_IOdg4.cjs';
 export { a as ObservedOutcomeStatus } from './types-BA_IOdg4.cjs';
 import './writers.cjs';

package/packages/core/dist/advanced.d.ts

@@ -6,8 +6,8 @@ import { a as InspectRunTree } from './inspect-event-ClM5Z8om.js';
 export { b as ATTRIBUTION_CONFIDENCES, c as ATTRIBUTION_CONFIDENCE_RANK, A as AttributionConfidence, E as EventSource, d as InspectEvent, I as InspectKind, e as InspectNode, i as isAttributionConfidence } from './inspect-event-ClM5Z8om.js';
 import { P as PersistedInspectEvent } from './persisted-inspect-event-DG02LhEP.js';
 import { Stats } from 'node:fs';
-import { aR as SessionWorkflowMetadata, aS as SessionRunRecord, aT as EnrichSessionSummaryOptions, aU as SessionStatus, aV as SessionSummary, aW as SessionIndex, aX as BuildActivitySummaryOptions, aY as ActivitySummary, aZ as SessionWarning, a_ as BuildSessionIndexOptions, N as TraceCheckResult, X as TraceCheckStatus, a2 as TraceContractInput, Z as TraceContract } from './index-7hG_qggp.js';
-export { a$ as ActivityEntry, b0 as CriticalPathStep, b1 as HandoffEdge, b2 as RetryLink, b3 as SESSION_WORKFLOW_KEYS, b4 as SessionCheckSummary, b5 as SessionConfidence, b6 as SessionEdgeSource, b7 as SessionGroup, b8 as SessionLastError, b9 as SessionWorkflowKey } from './index-7hG_qggp.js';
+import { aZ as SessionWorkflowMetadata, a_ as SessionRunRecord, a$ as EnrichSessionSummaryOptions, b0 as SessionStatus, b1 as SessionSummary, b2 as SessionIndex, b3 as BuildActivitySummaryOptions, b4 as ActivitySummary, b5 as SessionWarning, b6 as BuildSessionIndexOptions, U as TraceCheckResult, _ as TraceCheckStatus, a5 as TraceContractInput, a0 as TraceContract } from './index-CgOAGuM5.js';
+export { b7 as ActivityEntry, b8 as CriticalPathStep, b9 as HandoffEdge, ba as RetryLink, bb as SESSION_WORKFLOW_KEYS, bc as SessionCheckSummary, bd as SessionConfidence, be as SessionEdgeSource, bf as SessionGroup, bg as SessionLastError, bh as SessionWorkflowKey } from './index-CgOAGuM5.js';
 import { b as ObservedOutcome } from './types-BA_IOdg4.js';
 export { a as ObservedOutcomeStatus } from './types-BA_IOdg4.js';
 import './writers.js';

package/packages/core/dist/advanced.mjs

@@ -1,5 +1,5 @@
-import { extractSessionWorkflowMetadata, sessionKeyForRun, defineTraceContract, runTraceChecks, createRunStatusRule, createToolUsageRule, createRunDurationRule, createLlmUsageRule, createObservedOutcomeRule } from './chunk-OOX25GTH.mjs';
-export { extractSessionWorkflowMetadata, sessionKeyForRun } from './chunk-OOX25GTH.mjs';
+import { extractSessionWorkflowMetadata, sessionKeyForRun, defineTraceContract, runTraceChecks, createRunStatusRule, createToolUsageRule, createRunDurationRule, createLlmUsageRule, createObservedOutcomeRule } from './chunk-CBPWLHNQ.mjs';
+export { extractSessionWorkflowMetadata, sessionKeyForRun } from './chunk-CBPWLHNQ.mjs';
 export { MAX_TERMINAL_DEPTH, MAX_TERMINAL_NAME_LENGTH, TERMINAL_INDENT, TraceDirectory, createInspector, createInspectorRuntime, formatTerminalName, getCurrentContext, getCurrentCorrelationMetadata, getCurrentDepth, getCurrentRunId, getCurrentRunName, getCurrentStepId, getIndent, getParentStepId, getTraceDirFromContext, getTraceSafetyFromContext, hasActiveContext, isAgentInspectEnabled, isSilentContext, maybeInspectRun, printError, printFailedAt, printRunComplete, printRunStart, printStepComplete, printStepStart, renderErrorLine, renderRunSummary, renderStepLine, resolveTraceDir, runWithContext, runWithStepContext } from './chunk-ZFJ2ICTC.mjs';
 import { buildRunTimeline, filterTraces, extractMetadata, buildRunSummary } from './chunk-KWBO36PH.mjs';
 export { buildRunSummary, buildRunTimeline, buildRunWhatSummary, buildTraceStats, extractMetadata, filterTraces, formatStepLabel, renderRunWhat, renderTimeline, renderTraceStats } from './chunk-KWBO36PH.mjs';

package/packages/core/dist/checks.cjs

@@ -2490,11 +2490,40 @@ function contractFailFinding(ruleId, message, evidence, expected, actual) {
     evidence: [...evidence]
   };
 }
+var ALLOWED_STATUS_ALIASES = {
+  ok: "ok",
+  error: "error",
+  running: "running",
+  success: "ok",
+  failed: "error"
+};
+function parseAllowedStatus(status) {
+  return ALLOWED_STATUS_ALIASES[status];
+}
 function normalizeStatus(status) {
-  if (status === "ok" || status === "error" || status === "running") return status;
-  if (status === "success") return "ok";
-  if (status === "failed") return "error";
-  return "error";
+  const parsed = parseAllowedStatus(status);
+  if (parsed === void 0) {
+    throw new TypeError(
+      `Unknown run status ${JSON.stringify(status)}. Allowed: ok, error, running (aliases: success, failed).`
+    );
+  }
+  return parsed;
+}
+function validateAllowedStatusesShape(allowedStatuses, pathPrefix = "run.allowedStatuses") {
+  if (!allowedStatuses?.length) return [];
+  const out = [];
+  for (let i = 0; i < allowedStatuses.length; i++) {
+    const status = allowedStatuses[i];
+    if (parseAllowedStatus(status) === void 0) {
+      out.push({
+        code: "contract.run.allowedStatuses.unknown",
+        severity: "error",
+        message: `${pathPrefix}[${i}] has unknown status ${JSON.stringify(status)}. Allowed: ok, error, running (aliases: success, failed).`,
+        path: `${pathPrefix}[${i}]`
+      });
+    }
+  }
+  return out;
 }
 function cloneBody(body) {
   return {
@@ -2507,6 +2536,17 @@ function cloneBody(body) {
       }
     } : {},
     ...body.llm ? { llm: { ...body.llm } } : {},
+    ...body.steps ? {
+      steps: {
+        ...body.steps.orderRelations ? {
+          orderRelations: body.steps.orderRelations.map((item) => ({
+            ...item,
+            before: { ...item.before },
+            after: { ...item.after }
+          }))
+        } : {}
+      }
+    } : {},
     ...body.observations ? {
       observations: {
         ...body.observations,
@@ -2546,7 +2586,7 @@ function cloneBody(body) {
   };
 }
 function bodyHasRules(body) {
-  return body.run !== void 0 || body.tools !== void 0 || body.llm !== void 0 || body.observations !== void 0 || body.controls !== void 0 || body.retry !== void 0;
+  return body.run !== void 0 || body.tools !== void 0 || body.llm !== void 0 || body.steps !== void 0 || body.observations !== void 0 || body.controls !== void 0 || body.retry !== void 0;
 }
 var MAX_EVIDENCE_EVENT_IDS = 16;
 var METHOD_VOCABULARY = new Set(OBSERVED_OUTCOME_METHODS);
@@ -2889,6 +2929,18 @@ function contractToRules(contract) {
       })
     );
   }
+  const orderRelations = contract.steps?.orderRelations ?? [];
+  for (const [index, relation] of orderRelations.entries()) {
+    rules.push(
+      createStepOrderingRule({
+        before: { kind: relation.before.kind, name: relation.before.name },
+        after: { kind: relation.after.kind, name: relation.after.name },
+        id: `contract.step.orderRelation.${index}`,
+        mode: relation.mode ?? "first-occurrence",
+        requireEndpoints: relation.requireEndpoints !== false
+      })
+    );
+  }
   if (contract.observations) {
     const required = contract.observations.required ?? [];
     if (required.length > 0) {
@@ -3138,6 +3190,7 @@ function evaluateBody(input, body, options = {}) {
 }
 function defineTraceContract(input) {
   const shapeErrors = [
+    ...validateAllowedStatusesShape(input.run?.allowedStatuses),
     ...validateAlternativesShape(input.alternatives),
     ...validateScopeShape(input.scope),
     ...validateProvenanceShape(input.observations)
@@ -3168,6 +3221,7 @@ function defineTraceContract(input) {
 }
 function evaluateTraceContract(input, contract, options = {}) {
   const shapeErrors = [
+    ...validateAllowedStatusesShape(contract.run?.allowedStatuses),
     ...validateAlternativesShape(contract.alternatives),
     ...validateScopeShape(contract.scope),
     ...validateProvenanceShape(contract.observations)
@@ -3442,6 +3496,13 @@ function explainTraceContract(contract) {
       lines.push(`Base: LLM allowedModels [${contract.llm.allowedModels.join(", ")}].`);
     }
   }
+  if ((contract.steps?.orderRelations?.length ?? 0) > 0) {
+    const relations = contract.steps.orderRelations;
+    const summary = relations.map(
+      (relation) => `${relation.before.kind}:${relation.before.name} \u2192 ${relation.after.kind}:${relation.after.name} mode=${relation.mode ?? "first-occurrence"}`
+    ).join("; ");
+    lines.push(`Base: ${relations.length} steps.orderRelations [${summary}].`);
+  }
   if (contract.observations?.required?.length) {
     lines.push(`Base: required observations [${contract.observations.required.join(", ")}].`);
   }
@@ -3856,6 +3917,31 @@ function failFinding(ruleId, message, evidence, expected, actual, meta) {
 function toolName(event) {
   return resolveCanonicalToolName(event);
 }
+function stepEndpointName(event, kind) {
+  if (kind === "TOOL") return resolveCanonicalToolName(event);
+  for (const prefix of ["llm:", "generation:", "transcription:", "speech:"]) {
+    if (event.name.startsWith(prefix)) return event.name.slice(prefix.length);
+  }
+  return event.name;
+}
+function formatStepEndpoint(endpoint) {
+  return `${endpoint.kind} ${endpoint.name}`;
+}
+function otherKindsForStepName(context, expectedKind, name) {
+  return [
+    ...new Set(
+      semanticEvents(context).filter((event) => {
+        const kind = typeof event.kind === "string" ? event.kind.toUpperCase() : "";
+        if (kind === expectedKind) return false;
+        if (kind === "TOOL") return resolveCanonicalToolName(event) === name;
+        if (kind === "LLM") return stepEndpointName(event, "LLM") === name;
+        return event.name === name || event.name === `tool:${name}` || event.name === `llm:${name}` || event.name.endsWith(`:${name}`);
+      }).map(
+        (event) => typeof event.kind === "string" ? event.kind.toUpperCase() : "UNKNOWN"
+      )
+    )
+  ].sort();
+}
 function semanticEvents(context) {
   return context.logicalEvents ?? context.events;
 }
@@ -3882,14 +3968,6 @@ function finishedEvents(context, kind) {
 function toolInvocationEvents(context) {
   return semanticEvents(context).filter((event) => event.kind === "TOOL");
 }
-function firstIndexByName(events) {
-  const index = /* @__PURE__ */ new Map();
-  for (const [position, event] of events.entries()) {
-    const name = toolName(event);
-    if (!index.has(name)) index.set(name, position);
-  }
-  return index;
-}
 function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -4399,18 +4477,85 @@ function createToolUsageRule(options) {
     }
   };
 }
-function createToolOrderingRule(options) {
-  const ruleId = options.id ?? "tool.order";
+function createStepOrderingRule(options) {
+  const bothTools = options.before.kind === "TOOL" && options.after.kind === "TOOL";
+  const ruleId = options.id ?? (bothTools ? "tool.order" : "step.order");
   const mode = options.mode ?? "first-occurrence";
+  const requireEndpoints = options.requireEndpoints === true;
+  const beforeLabel = bothTools ? options.before.name : formatStepEndpoint(options.before);
+  const afterLabel = bothTools ? options.after.name : formatStepEndpoint(options.after);
+  const subject = bothTools ? "Tool" : "Step";
   return {
     id: ruleId,
-    category: "tool",
+    category: bothTools ? "tool" : "structure",
     defaultSeverity: "error",
     evaluate(context) {
-      const tools = finishedEvents(context, "TOOL");
-      const index = firstIndexByName(tools);
-      const beforeIndex = index.get(options.before);
-      const afterIndex = index.get(options.after);
+      const beforeEvents = finishedEvents(context, options.before.kind).filter(
+        (event) => stepEndpointName(event, options.before.kind) === options.before.name
+      );
+      const afterEvents = finishedEvents(context, options.after.kind).filter(
+        (event) => stepEndpointName(event, options.after.kind) === options.after.name
+      );
+      if (beforeEvents.length === 0 || afterEvents.length === 0) {
+        if (!requireEndpoints) return [];
+        const findings = [];
+        if (beforeEvents.length === 0) {
+          const otherKinds = otherKindsForStepName(
+            context,
+            options.before.kind,
+            options.before.name
+          );
+          const hint = otherKinds.length > 0 ? ` Required name appears under non-${options.before.kind} kind(s): ${otherKinds.join(", ")}.` : "";
+          findings.push(
+            failFinding(
+              ruleId,
+              `Required ${formatStepEndpoint(options.before)} did not appear.${hint}`,
+              runEvidence(context.selectedRun),
+              options.before,
+              {
+                code: bothTools ? "tool.order.missing-endpoint" : "step.order.missing-endpoint",
+                endpoint: "before",
+                otherKinds
+              }
+            )
+          );
+        }
+        if (afterEvents.length === 0) {
+          const otherKinds = otherKindsForStepName(
+            context,
+            options.after.kind,
+            options.after.name
+          );
+          const hint = otherKinds.length > 0 ? ` Required name appears under non-${options.after.kind} kind(s): ${otherKinds.join(", ")}.` : "";
+          findings.push(
+            failFinding(
+              ruleId,
+              `Required ${formatStepEndpoint(options.after)} did not appear.${hint}`,
+              runEvidence(context.selectedRun),
+              options.after,
+              {
+                code: bothTools ? "tool.order.missing-endpoint" : "step.order.missing-endpoint",
+                endpoint: "after",
+                otherKinds
+              }
+            )
+          );
+        }
+        return findings;
+      }
+      const encounter = finishedEvents(context).filter(
+        (event) => event.kind === options.before.kind && stepEndpointName(event, options.before.kind) === options.before.name || event.kind === options.after.kind && stepEndpointName(event, options.after.kind) === options.after.name
+      );
+      let beforeIndex;
+      let afterIndex;
+      for (const [position, event] of encounter.entries()) {
+        if (beforeIndex === void 0 && event.kind === options.before.kind && stepEndpointName(event, options.before.kind) === options.before.name) {
+          beforeIndex = position;
+        }
+        if (afterIndex === void 0 && event.kind === options.after.kind && stepEndpointName(event, options.after.kind) === options.after.name) {
+          afterIndex = position;
+        }
+      }
       if (beforeIndex === void 0 || afterIndex === void 0) {
         return [];
       }
@@ -4418,32 +4563,37 @@ function createToolOrderingRule(options) {
         return [
           failFinding(
             ruleId,
-            `Tool ${options.before} must appear before ${options.after}.`,
-            [eventEvidence3(tools[beforeIndex]), eventEvidence3(tools[afterIndex])],
-            { before: options.before, after: options.after },
-            tools.map(toolName)
+            `${subject} ${beforeLabel} must appear before ${afterLabel}.`,
+            [
+              eventEvidence3(encounter[beforeIndex]),
+              eventEvidence3(encounter[afterIndex])
+            ],
+            bothTools ? { before: options.before.name, after: options.after.name } : { before: options.before, after: options.after },
+            bothTools ? finishedEvents(context, "TOOL").map(toolName) : encounter.map(
+              (event) => event.kind === "TOOL" || event.kind === "LLM" ? `${event.kind}:${stepEndpointName(event, event.kind)}` : event.name
+            )
           )
         ];
       }
-      const beforeEvent = tools[beforeIndex];
-      const afterEvent = tools[afterIndex];
+      const beforeEvent = beforeEvents[0];
+      const afterEvent = afterEvents[0];
       const beforeEnd = eventEndMs(beforeEvent);
       const afterStart = eventStartMs(afterEvent);
+      const endpointExpected = bothTools ? { before: options.before.name, after: options.after.name } : { before: options.before, after: options.after };
       if (mode === "happens-before") {
         const expected = {
-          before: options.before,
-          after: options.after,
+          ...endpointExpected,
           mode,
           relation: "before.end <= after.start"
         };
-        if (options.before === options.after) {
+        if (options.before.kind === options.after.kind && options.before.name === options.after.name) {
           return [
             failFinding(
               ruleId,
-              `Tool ${options.before} cannot causally happen before itself.`,
+              `${subject} ${beforeLabel} cannot causally happen before itself.`,
               [eventEvidence3(beforeEvent)],
               expected,
-              { code: "tool.order.same-tool" }
+              { code: bothTools ? "tool.order.same-tool" : "step.order.same-step" }
             )
           ];
         }
@@ -4451,11 +4601,11 @@ function createToolOrderingRule(options) {
           return [
             failFinding(
               ruleId,
-              `Tool order ${options.before} before ${options.after} could not establish causal timing.`,
+              `${subject} order ${beforeLabel} before ${afterLabel} could not establish causal timing.`,
               [eventEvidence3(beforeEvent), eventEvidence3(afterEvent)],
               expected,
               {
-                code: "tool.order.interval-unresolved",
+                code: bothTools ? "tool.order.interval-unresolved" : "step.order.interval-unresolved",
                 beforeEndResolved: beforeEnd !== void 0,
                 afterStartResolved: afterStart !== void 0
               }
@@ -4466,7 +4616,7 @@ function createToolOrderingRule(options) {
           return [
             failFinding(
               ruleId,
-              `Tool ${options.before} must finish before ${options.after} starts.`,
+              `${subject} ${beforeLabel} must finish before ${afterLabel} starts.`,
               [eventEvidence3(beforeEvent), eventEvidence3(afterEvent)],
               expected,
               {
@@ -4479,22 +4629,19 @@ function createToolOrderingRule(options) {
         return [];
       }
       if (mode === "all-occurrences") {
-        const beforeEvents = tools.filter((event) => toolName(event) === options.before);
-        const afterEvents = tools.filter((event) => toolName(event) === options.after);
         const expected = {
-          before: options.before,
-          after: options.after,
+          ...endpointExpected,
           mode,
           relation: "max(before.end) <= min(after.start)"
         };
-        if (options.before === options.after) {
+        if (options.before.kind === options.after.kind && options.before.name === options.after.name) {
           return [
             failFinding(
               ruleId,
-              `Tool ${options.before} cannot causally happen before itself.`,
+              `${subject} ${beforeLabel} cannot causally happen before itself.`,
               [eventEvidence3(beforeEvent)],
               expected,
-              { code: "tool.order.same-tool" }
+              { code: bothTools ? "tool.order.same-tool" : "step.order.same-step" }
             )
           ];
         }
@@ -4526,11 +4673,11 @@ function createToolOrderingRule(options) {
           return [
             failFinding(
               ruleId,
-              `Tool order ${options.before} before ${options.after} could not establish all causal intervals.`,
+              `${subject} order ${beforeLabel} before ${afterLabel} could not establish all causal intervals.`,
               [firstMissingBefore, firstMissingAfter].filter((event) => event !== void 0).map((event) => eventEvidence3(event)),
               expected,
               {
-                code: "tool.order.interval-unresolved",
+                code: bothTools ? "tool.order.interval-unresolved" : "step.order.interval-unresolved",
                 missingBeforeEnds,
                 missingAfterStarts
               }
@@ -4541,7 +4688,7 @@ function createToolOrderingRule(options) {
           return [
             failFinding(
               ruleId,
-              `Every ${options.before} tool call must finish before any ${options.after} tool call starts.`,
+              bothTools ? `Every ${options.before.name} tool call must finish before any ${options.after.name} tool call starts.` : `Every ${beforeLabel} must finish before any ${afterLabel} starts.`,
               [eventEvidence3(latestBefore.event), eventEvidence3(earliestAfter.event)],
               expected,
               {
@@ -4559,10 +4706,13 @@ function createToolOrderingRule(options) {
             ruleId,
             severity: "warning",
             status: "warning",
-            message: `Tool order ${options.before} before ${options.after} satisfied start/encounter order, but intervals overlap so causal completion before the next tool was not established.`,
-            expected: { before: options.before, after: options.after, mode: "first-occurrence" },
+            message: `${subject} order ${beforeLabel} before ${afterLabel} satisfied start/encounter order, but intervals overlap so causal completion before the next ${bothTools ? "tool" : "step"} was not established.`,
+            expected: {
+              ...endpointExpected,
+              mode: "first-occurrence"
+            },
             actual: {
-              code: "tool.order.overlap",
+              code: bothTools ? "tool.order.overlap" : "step.order.overlap",
               beforeEndedAt: beforeEvent.endedAt,
               afterStartedAt: afterEvent.startedAt ?? afterEvent.timestamp
             },
@@ -4574,6 +4724,15 @@ function createToolOrderingRule(options) {
     }
   };
 }
+function createToolOrderingRule(options) {
+  return createStepOrderingRule({
+    before: { kind: "TOOL", name: options.before },
+    after: { kind: "TOOL", name: options.after },
+    ...options.id !== void 0 ? { id: options.id } : {},
+    ...options.mode !== void 0 ? { mode: options.mode } : {},
+    requireEndpoints: false
+  });
+}
 function createToolFailureRule(options) {
   return {
     id: "tool.failures",
@@ -5517,6 +5676,7 @@ exports.createSafetyRawContentRule = createSafetyRawContentRule;
 exports.createSafetyRedactionRule = createSafetyRedactionRule;
 exports.createSafetySecretPatternRule = createSafetySecretPatternRule;
 exports.createStallDetectionRule = createStallDetectionRule;
+exports.createStepOrderingRule = createStepOrderingRule;
 exports.createStructureCycleRule = createStructureCycleRule;
 exports.createStructureIncompleteRule = createStructureIncompleteRule;
 exports.createStructureOrphanRule = createStructureOrphanRule;