@opensteer/protocol 0.8.0 → 0.8.2

package/dist/index.cjs

@@ -833,55 +833,6 @@ var orderedHeadersSchema = arraySchema(headerEntrySchema, {
   title: "OrderedHeaders"
 });
 
-// src/captcha.ts
-var captchaTypeSchema = enumSchema(
-  ["recaptcha-v2", "hcaptcha", "turnstile"],
-  {
-    title: "CaptchaType"
-  }
-);
-var captchaProviderSchema = enumSchema(["2captcha", "capsolver"], {
-  title: "CaptchaProvider"
-});
-var captchaDetectionResultSchema = objectSchema(
-  {
-    type: captchaTypeSchema,
-    siteKey: stringSchema({ minLength: 1 }),
-    pageUrl: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "CaptchaDetectionResult",
-    required: ["type", "siteKey", "pageUrl"]
-  }
-);
-var opensteerCaptchaSolveInputSchema = objectSchema(
-  {
-    provider: captchaProviderSchema,
-    apiKey: stringSchema({ minLength: 1 }),
-    pageRef: pageRefSchema,
-    timeoutMs: integerSchema({ minimum: 1 }),
-    type: captchaTypeSchema,
-    siteKey: stringSchema({ minLength: 1 }),
-    pageUrl: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerCaptchaSolveInput",
-    required: ["provider", "apiKey"]
-  }
-);
-var opensteerCaptchaSolveOutputSchema = objectSchema(
-  {
-    captcha: captchaDetectionResultSchema,
-    token: stringSchema({ minLength: 1 }),
-    injected: { type: "boolean" },
-    provider: captchaProviderSchema
-  },
-  {
-    title: "OpensteerCaptchaSolveOutput",
-    required: ["captcha", "token", "injected", "provider"]
-  }
-);
-
 // src/storage.ts
 var jsonUnknownSchema = {};
 var cookieSameSiteSchema = enumSchema(["strict", "lax", "none"], {
@@ -1134,17 +1085,6 @@ var opensteerRequestPlanResponseExpectationSchema = objectSchema(
     required: ["status"]
   }
 );
-var opensteerRecipeRefSchema = objectSchema(
-  {
-    key: stringSchema({ minLength: 1 }),
-    version: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerRecipeRef",
-    required: ["key"]
-  }
-);
-var opensteerAuthRecipeRefSchema = opensteerRecipeRefSchema;
 var opensteerRequestFailurePolicyHeaderMatchSchema = objectSchema(
   {
     name: stringSchema({ minLength: 1 }),
@@ -1200,46 +1140,9 @@ var opensteerRequestRetryPolicySchema = objectSchema(
     required: ["maxRetries"]
   }
 );
-var opensteerRecipeCachePolicySchema = enumSchema(
-  ["none", "untilFailure"],
-  {
-    title: "OpensteerRecipeCachePolicy"
-  }
-);
-var opensteerRequestPlanRecipeBindingSchema = objectSchema(
-  {
-    recipe: opensteerRecipeRefSchema,
-    cachePolicy: opensteerRecipeCachePolicySchema
-  },
-  {
-    title: "OpensteerRequestPlanRecipeBinding",
-    required: ["recipe"]
-  }
-);
-var opensteerRequestPlanRecoverBindingSchema = objectSchema(
-  {
-    recipe: opensteerRecipeRefSchema,
-    cachePolicy: opensteerRecipeCachePolicySchema,
-    failurePolicy: opensteerRequestFailurePolicySchema
-  },
-  {
-    title: "OpensteerRequestPlanRecoverBinding",
-    required: ["recipe", "failurePolicy"]
-  }
-);
-var opensteerRequestPlanRecipesSchema = objectSchema(
-  {
-    prepare: opensteerRequestPlanRecipeBindingSchema,
-    recover: opensteerRequestPlanRecoverBindingSchema
-  },
-  {
-    title: "OpensteerRequestPlanRecipes"
-  }
-);
 var opensteerRequestPlanAuthSchema = objectSchema(
   {
     strategy: enumSchema(["session-cookie", "bearer-token", "api-key", "custom"]),
-    recipe: opensteerRecipeRefSchema,
     failurePolicy: opensteerRequestFailurePolicySchema,
     description: stringSchema({ minLength: 1 })
   },
@@ -1255,7 +1158,6 @@ var opensteerRequestPlanPayloadSchema = objectSchema(
     parameters: arraySchema(opensteerRequestPlanParameterSchema),
     body: opensteerRequestPlanBodySchema,
     response: opensteerRequestPlanResponseExpectationSchema,
-    recipes: opensteerRequestPlanRecipesSchema,
     retryPolicy: opensteerRequestRetryPolicySchema,
     auth: opensteerRequestPlanAuthSchema
   },
@@ -1346,321 +1248,6 @@ var opensteerRequestBodyInputSchema = oneOfSchema(
     title: "OpensteerRequestBodyInput"
   }
 );
-var opensteerRecipeRetryOverridesSchema = objectSchema(
-  {
-    params: recordSchema(stringSchema(), {
-      title: "OpensteerRecipeParams"
-    }),
-    headers: recordSchema(stringSchema(), {
-      title: "OpensteerRecipeHeaders"
-    }),
-    query: recordSchema(stringSchema(), {
-      title: "OpensteerRecipeQuery"
-    }),
-    body: recordSchema(stringSchema(), {
-      title: "OpensteerRecipeBodyVariables"
-    })
-  },
-  {
-    title: "OpensteerRecipeRetryOverrides"
-  }
-);
-var opensteerRecipeStepResponseCaptureSchema = objectSchema(
-  {
-    header: objectSchema(
-      {
-        name: stringSchema({ minLength: 1 }),
-        saveAs: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerAuthRecipeHeaderCapture",
-        required: ["name", "saveAs"]
-      }
-    ),
-    bodyJsonPointer: objectSchema(
-      {
-        pointer: stringSchema({ minLength: 1 }),
-        saveAs: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerAuthRecipeBodyJsonPointerCapture",
-        required: ["pointer", "saveAs"]
-      }
-    ),
-    bodyText: objectSchema(
-      {
-        saveAs: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerAuthRecipeBodyTextCapture",
-        required: ["saveAs"]
-      }
-    )
-  },
-  {
-    title: "OpensteerRecipeStepResponseCapture"
-  }
-);
-var opensteerRecipeRequestStepInputSchema = objectSchema(
-  {
-    url: stringSchema({ minLength: 1 }),
-    transport: transportKindSchema,
-    pageRef: pageRefSchema,
-    cookieJar: stringSchema({ minLength: 1 }),
-    method: stringSchema({ minLength: 1 }),
-    headers: recordSchema(stringSchema(), {
-      title: "OpensteerRecipeRequestHeaders"
-    }),
-    query: recordSchema(stringSchema(), {
-      title: "OpensteerRecipeRequestQuery"
-    }),
-    body: opensteerRequestBodyInputSchema,
-    followRedirects: { type: "boolean" }
-  },
-  {
-    title: "OpensteerRecipeRequestStepInput",
-    required: ["url"]
-  }
-);
-var opensteerRecipeHookRefSchema = objectSchema(
-  {
-    specifier: stringSchema({ minLength: 1 }),
-    export: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerRecipeHookRef",
-    required: ["specifier", "export"]
-  }
-);
-var opensteerAuthRecipeHookRefSchema = opensteerRecipeHookRefSchema;
-var opensteerRecipeStepSchema = oneOfSchema(
-  [
-    objectSchema(
-      {
-        kind: enumSchema(["goto"]),
-        url: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerAuthRecipeGotoStep",
-        required: ["kind", "url"]
-      }
-    ),
-    objectSchema(
-      {
-        kind: enumSchema(["reload"])
-      },
-      {
-        title: "OpensteerAuthRecipeReloadStep",
-        required: ["kind"]
-      }
-    ),
-    objectSchema(
-      {
-        kind: enumSchema(["waitForUrl"]),
-        includes: stringSchema({ minLength: 1 }),
-        timeoutMs: integerSchema({ minimum: 0 })
-      },
-      {
-        title: "OpensteerAuthRecipeWaitForUrlStep",
-        required: ["kind", "includes"]
-      }
-    ),
-    objectSchema(
-      {
-        kind: enumSchema(["waitForNetwork"]),
-        url: stringSchema({ minLength: 1 }),
-        hostname: stringSchema({ minLength: 1 }),
-        path: stringSchema({ minLength: 1 }),
-        method: stringSchema({ minLength: 1 }),
-        status: stringSchema({ minLength: 1 }),
-        includeBodies: { type: "boolean" },
-        timeoutMs: integerSchema({ minimum: 0 }),
-        saveAs: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerRecipeWaitForNetworkStep",
-        required: ["kind"]
-      }
-    ),
-    objectSchema(
-      {
-        kind: enumSchema(["waitForCookie"]),
-        name: stringSchema({ minLength: 1 }),
-        url: stringSchema({ minLength: 1 }),
-        timeoutMs: integerSchema({ minimum: 0 }),
-        saveAs: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerAuthRecipeWaitForCookieStep",
-        required: ["kind", "name"]
-      }
-    ),
-    objectSchema(
-      {
-        kind: enumSchema(["waitForStorage"]),
-        area: enumSchema(["local", "session"]),
-        origin: stringSchema({ minLength: 1 }),
-        key: stringSchema({ minLength: 1 }),
-        timeoutMs: integerSchema({ minimum: 0 }),
-        saveAs: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerAuthRecipeWaitForStorageStep",
-        required: ["kind", "area", "origin", "key"]
-      }
-    ),
-    objectSchema(
-      {
-        kind: enumSchema(["readCookie"]),
-        name: stringSchema({ minLength: 1 }),
-        url: stringSchema({ minLength: 1 }),
-        saveAs: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerAuthRecipeReadCookieStep",
-        required: ["kind", "name", "saveAs"]
-      }
-    ),
-    objectSchema(
-      {
-        kind: enumSchema(["readStorage"]),
-        area: enumSchema(["local", "session"]),
-        origin: stringSchema({ minLength: 1 }),
-        key: stringSchema({ minLength: 1 }),
-        pageUrl: stringSchema({ minLength: 1 }),
-        saveAs: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerRecipeReadStorageStep",
-        required: ["kind", "area", "origin", "key", "saveAs"]
-      }
-    ),
-    objectSchema(
-      {
-        kind: enumSchema(["evaluate"]),
-        script: stringSchema({ minLength: 1 }),
-        args: arraySchema(jsonValueSchema),
-        pageRef: pageRefSchema,
-        saveAs: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerRecipeEvaluateStep",
-        required: ["kind", "script"]
-      }
-    ),
-    objectSchema(
-      {
-        kind: enumSchema(["syncCookiesToJar"]),
-        jar: stringSchema({ minLength: 1 }),
-        urls: arraySchema(stringSchema({ minLength: 1 }), {
-          minItems: 1
-        })
-      },
-      {
-        title: "OpensteerRecipeSyncCookiesToJarStep",
-        required: ["kind", "jar"]
-      }
-    ),
-    objectSchema(
-      {
-        kind: enumSchema(["request"]),
-        request: opensteerRecipeRequestStepInputSchema,
-        capture: opensteerRecipeStepResponseCaptureSchema
-      },
-      {
-        title: "OpensteerRecipeRequestStep",
-        required: ["kind", "request"]
-      }
-    ),
-    objectSchema(
-      {
-        kind: enumSchema(["sessionRequest"]),
-        request: opensteerRecipeRequestStepInputSchema,
-        capture: opensteerRecipeStepResponseCaptureSchema
-      },
-      {
-        title: "OpensteerAuthRecipeSessionRequestStep",
-        required: ["kind", "request"]
-      }
-    ),
-    objectSchema(
-      {
-        kind: enumSchema(["directRequest"]),
-        request: opensteerRecipeRequestStepInputSchema,
-        capture: opensteerRecipeStepResponseCaptureSchema
-      },
-      {
-        title: "OpensteerAuthRecipeDirectRequestStep",
-        required: ["kind", "request"]
-      }
-    ),
-    objectSchema(
-      {
-        kind: enumSchema(["solveCaptcha"]),
-        provider: captchaProviderSchema,
-        apiKey: stringSchema({ minLength: 1 }),
-        pageRef: pageRefSchema,
-        timeoutMs: integerSchema({ minimum: 1 }),
-        type: captchaTypeSchema,
-        siteKey: stringSchema({ minLength: 1 }),
-        pageUrl: stringSchema({ minLength: 1 }),
-        saveAs: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerRecipeSolveCaptchaStep",
-        required: ["kind", "provider", "apiKey"]
-      }
-    ),
-    objectSchema(
-      {
-        kind: enumSchema(["hook"]),
-        hook: opensteerRecipeHookRefSchema
-      },
-      {
-        title: "OpensteerRecipeHookStep",
-        required: ["kind", "hook"]
-      }
-    )
-  ],
-  {
-    title: "OpensteerRecipeStep"
-  }
-);
-var opensteerAuthRecipeStepSchema = opensteerRecipeStepSchema;
-var opensteerRecipePayloadSchema = objectSchema(
-  {
-    description: stringSchema({ minLength: 1 }),
-    steps: arraySchema(opensteerRecipeStepSchema, {
-      minItems: 1
-    }),
-    outputs: opensteerRecipeRetryOverridesSchema
-  },
-  {
-    title: "OpensteerRecipePayload",
-    required: ["steps"]
-  }
-);
-var opensteerAuthRecipePayloadSchema = opensteerRecipePayloadSchema;
-var opensteerRecipeRecordSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    key: stringSchema({ minLength: 1 }),
-    version: stringSchema({ minLength: 1 }),
-    createdAt: integerSchema({ minimum: 0 }),
-    updatedAt: integerSchema({ minimum: 0 }),
-    contentHash: stringSchema({ minLength: 1 }),
-    tags: arraySchema(stringSchema({ minLength: 1 }), {
-      uniqueItems: true
-    }),
-    provenance: opensteerRegistryProvenanceSchema,
-    payload: opensteerRecipePayloadSchema
-  },
-  {
-    title: "OpensteerRecipeRecord",
-    required: ["id", "key", "version", "createdAt", "updatedAt", "contentHash", "tags", "payload"]
-  }
-);
-var opensteerAuthRecipeRecordSchema = opensteerRecipeRecordSchema;
 var opensteerNetworkQueryInputSchema = objectSchema(
   {
     pageRef: pageRefSchema,
@@ -2060,92 +1647,7 @@ var opensteerListRequestPlansOutputSchema = objectSchema(
     required: ["plans"]
   }
 );
-var opensteerWriteRecipeInputSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    key: stringSchema({ minLength: 1 }),
-    version: stringSchema({ minLength: 1 }),
-    tags: arraySchema(stringSchema({ minLength: 1 }), {
-      uniqueItems: true
-    }),
-    provenance: opensteerRegistryProvenanceSchema,
-    payload: opensteerRecipePayloadSchema
-  },
-  {
-    title: "OpensteerWriteRecipeInput",
-    required: ["key", "version", "payload"]
-  }
-);
-var opensteerWriteAuthRecipeInputSchema = opensteerWriteRecipeInputSchema;
-var opensteerGetRecipeInputSchema = objectSchema(
-  {
-    key: stringSchema({ minLength: 1 }),
-    version: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerGetRecipeInput",
-    required: ["key"]
-  }
-);
-var opensteerGetAuthRecipeInputSchema = opensteerGetRecipeInputSchema;
-var opensteerListRecipesInputSchema = objectSchema(
-  {
-    key: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerListRecipesInput"
-  }
-);
-var opensteerListAuthRecipesInputSchema = opensteerListRecipesInputSchema;
-var opensteerListRecipesOutputSchema = objectSchema(
-  {
-    recipes: arraySchema(opensteerRecipeRecordSchema)
-  },
-  {
-    title: "OpensteerListRecipesOutput",
-    required: ["recipes"]
-  }
-);
-var opensteerListAuthRecipesOutputSchema = opensteerListRecipesOutputSchema;
-var opensteerRunRecipeInputSchema = objectSchema(
-  {
-    key: stringSchema({ minLength: 1 }),
-    version: stringSchema({ minLength: 1 }),
-    variables: recordSchema(stringSchema(), {
-      title: "OpensteerRecipeVariables"
-    })
-  },
-  {
-    title: "OpensteerRunRecipeInput",
-    required: ["key"]
-  }
-);
-var opensteerRunAuthRecipeInputSchema = opensteerRunRecipeInputSchema;
-var opensteerRunRecipeOutputSchema = objectSchema(
-  {
-    recipe: objectSchema(
-      {
-        id: stringSchema({ minLength: 1 }),
-        key: stringSchema({ minLength: 1 }),
-        version: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerResolvedRecipeRef",
-        required: ["id", "key", "version"]
-      }
-    ),
-    variables: recordSchema(stringSchema(), {
-      title: "OpensteerResolvedRecipeVariables"
-    }),
-    overrides: opensteerRecipeRetryOverridesSchema
-  },
-  {
-    title: "OpensteerRunRecipeOutput",
-    required: ["recipe", "variables"]
-  }
-);
-var opensteerRunAuthRecipeOutputSchema = opensteerRunRecipeOutputSchema;
-var opensteerRequestExecuteInputSchema = objectSchema(
+var opensteerRequestExecuteInputSchema = objectSchema(
   {
     key: stringSchema({ minLength: 1 }),
     version: stringSchema({ minLength: 1 }),
@@ -2251,17 +1753,7 @@ var opensteerRequestExecuteOutputSchema = objectSchema(
       {
         attempted: { type: "boolean" },
         succeeded: { type: "boolean" },
-        matchedFailurePolicy: { type: "boolean" },
-        recipe: objectSchema(
-          {
-            key: stringSchema({ minLength: 1 }),
-            version: stringSchema({ minLength: 1 })
-          },
-          {
-            title: "OpensteerResolvedRecoveryRecipeRef",
-            required: ["key", "version"]
-          }
-        )
+        matchedFailurePolicy: { type: "boolean" }
       },
       {
         title: "OpensteerRequestRecoveryMetadata",
@@ -2299,6 +1791,69 @@ var opensteerInferRequestPlanInputSchema = objectSchema(
     required: ["recordId", "key", "version"]
   }
 );
+
+// src/state.ts
+var opensteerStateSnapshotCookieSchema = objectSchema(
+  {
+    name: stringSchema({ minLength: 1 }),
+    value: stringSchema(),
+    domain: stringSchema({ minLength: 1 }),
+    path: stringSchema({ minLength: 1 }),
+    secure: { type: "boolean" },
+    httpOnly: { type: "boolean" },
+    sameSite: enumSchema(["strict", "lax", "none"]),
+    priority: enumSchema(["low", "medium", "high"]),
+    partitionKey: stringSchema({ minLength: 1 }),
+    session: { type: "boolean" },
+    expiresAt: oneOfSchema([integerSchema({ minimum: 0 }), { type: "null" }])
+  },
+  {
+    title: "OpensteerStateSnapshotCookie",
+    required: ["name", "value", "domain", "path", "secure", "httpOnly", "session"]
+  }
+);
+var opensteerStateSnapshotSchema = objectSchema(
+  {
+    id: stringSchema({ minLength: 1 }),
+    capturedAt: integerSchema({ minimum: 0 }),
+    pageRef: pageRefSchema,
+    url: stringSchema({ minLength: 1 }),
+    cookies: arraySchema(opensteerStateSnapshotCookieSchema),
+    storage: storageSnapshotSchema,
+    hiddenFields: arraySchema(
+      objectSchema(
+        {
+          path: stringSchema({ minLength: 1 }),
+          name: stringSchema({ minLength: 1 }),
+          value: stringSchema()
+        },
+        {
+          title: "OpensteerStateSnapshotHiddenField",
+          required: ["path", "name", "value"]
+        }
+      )
+    ),
+    globals: recordSchema({}, { title: "OpensteerStateSnapshotGlobals" })
+  },
+  {
+    title: "OpensteerStateSnapshot",
+    required: ["id", "capturedAt"]
+  }
+);
+var opensteerStateDeltaSchema = objectSchema(
+  {
+    beforeStateId: stringSchema({ minLength: 1 }),
+    afterStateId: stringSchema({ minLength: 1 }),
+    cookiesChanged: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
+    storageChanged: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
+    hiddenFieldsChanged: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
+    globalsChanged: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true })
+  },
+  {
+    title: "OpensteerStateDelta",
+    required: ["cookiesChanged", "storageChanged", "hiddenFieldsChanged", "globalsChanged"]
+  }
+);
 var screenshotFormatSchema = enumSchema(["png", "jpeg", "webp"], {
   title: "ScreenshotFormat"
 });
@@ -3413,6 +2968,55 @@ var opensteerArtifactReadOutputSchema = objectSchema(
   }
 );
 
+// src/captcha.ts
+var captchaTypeSchema = enumSchema(
+  ["recaptcha-v2", "hcaptcha", "turnstile"],
+  {
+    title: "CaptchaType"
+  }
+);
+var captchaProviderSchema = enumSchema(["2captcha", "capsolver"], {
+  title: "CaptchaProvider"
+});
+var captchaDetectionResultSchema = objectSchema(
+  {
+    type: captchaTypeSchema,
+    siteKey: stringSchema({ minLength: 1 }),
+    pageUrl: stringSchema({ minLength: 1 })
+  },
+  {
+    title: "CaptchaDetectionResult",
+    required: ["type", "siteKey", "pageUrl"]
+  }
+);
+var opensteerCaptchaSolveInputSchema = objectSchema(
+  {
+    provider: captchaProviderSchema,
+    apiKey: stringSchema({ minLength: 1 }),
+    pageRef: pageRefSchema,
+    timeoutMs: integerSchema({ minimum: 1 }),
+    type: captchaTypeSchema,
+    siteKey: stringSchema({ minLength: 1 }),
+    pageUrl: stringSchema({ minLength: 1 })
+  },
+  {
+    title: "OpensteerCaptchaSolveInput",
+    required: ["provider", "apiKey"]
+  }
+);
+var opensteerCaptchaSolveOutputSchema = objectSchema(
+  {
+    captcha: captchaDetectionResultSchema,
+    token: stringSchema({ minLength: 1 }),
+    injected: { type: "boolean" },
+    provider: captchaProviderSchema
+  },
+  {
+    title: "OpensteerCaptchaSolveOutput",
+    required: ["captcha", "token", "injected", "provider"]
+  }
+);
+
 // src/traces.ts
 var traceContextSchema = objectSchema(
   {
@@ -4685,1548 +4289,6 @@ var opensteerScriptSandboxOutputSchema = objectSchema(
   }
 );
 
-// src/reverse.ts
-var opensteerStateSourceKindSchema = enumSchema(
-  ["temporary", "persistent", "attach"],
-  { title: "OpensteerStateSourceKind" }
-);
-var opensteerReverseCaseStatusSchema = enumSchema(
-  ["capturing", "analyzing", "ready", "attention"],
-  { title: "OpensteerReverseCaseStatus" }
-);
-var opensteerReverseChannelKindSchema = enumSchema(
-  ["http", "event-stream", "websocket"],
-  { title: "OpensteerReverseChannelKind" }
-);
-var opensteerReverseManualCalibrationModeSchema = enumSchema(
-  ["allow", "avoid", "require"],
-  { title: "OpensteerReverseManualCalibrationMode" }
-);
-var opensteerReverseCandidateBoundarySchema = enumSchema(
-  ["first-party", "same-site", "third-party"],
-  { title: "OpensteerReverseCandidateBoundary" }
-);
-var opensteerReverseAdvisoryTagSchema = enumSchema(
-  [
-    "data",
-    "facet",
-    "telemetry",
-    "subscription",
-    "navigation",
-    "document",
-    "route-data",
-    "search",
-    "tracking",
-    "unknown"
-  ],
-  { title: "OpensteerReverseAdvisoryTag" }
-);
-var opensteerReverseConstraintKindSchema = enumSchema(
-  [
-    "requires-browser",
-    "requires-cookie",
-    "requires-storage",
-    "requires-script",
-    "requires-guard",
-    "requires-live-state",
-    "opaque-body",
-    "unsupported"
-  ],
-  { title: "OpensteerReverseConstraintKind" }
-);
-var opensteerRequestInputLocationSchema = enumSchema(
-  ["path", "query", "header", "cookie", "body-field"],
-  { title: "OpensteerRequestInputLocation" }
-);
-var opensteerRequestInputRequirednessSchema = enumSchema(
-  ["required", "optional", "unknown"],
-  { title: "OpensteerRequestInputRequiredness" }
-);
-var opensteerRequestInputClassificationSchema = enumSchema(
-  ["managed", "static", "contextual", "volatile"],
-  { title: "OpensteerRequestInputClassification" }
-);
-var opensteerRequestInputSourceSchema = enumSchema(
-  [
-    "literal",
-    "cookie",
-    "storage",
-    "prior-response",
-    "page",
-    "script",
-    "guard-output",
-    "runtime-managed",
-    "unknown"
-  ],
-  { title: "OpensteerRequestInputSource" }
-);
-var opensteerRequestInputMaterializationPolicySchema = enumSchema(
-  ["copy", "omit", "recompute", "resolve"],
-  { title: "OpensteerRequestInputMaterializationPolicy" }
-);
-var opensteerRequestInputExportPolicySchema = enumSchema(
-  ["portable", "browser-bound", "blocked"],
-  { title: "OpensteerRequestInputExportPolicy" }
-);
-var opensteerReverseQueryViewSchema = enumSchema(
-  ["records", "clusters", "candidates"],
-  { title: "OpensteerReverseQueryView" }
-);
-var opensteerReverseSortKeySchema = enumSchema(
-  [
-    "observed-at",
-    "advisory-rank",
-    "target-hint-matches",
-    "response-richness",
-    "portability",
-    "boundary",
-    "success"
-  ],
-  { title: "OpensteerReverseSortKey" }
-);
-var opensteerReverseSortPresetSchema = enumSchema(
-  [
-    "advisory-rank",
-    "observed-at",
-    "portability",
-    "first-party",
-    "hint-match",
-    "response-richness"
-  ],
-  { title: "OpensteerReverseSortPreset" }
-);
-var opensteerReverseSortDirectionSchema = enumSchema(
-  ["asc", "desc"],
-  {
-    title: "OpensteerReverseSortDirection"
-  }
-);
-var opensteerObservationClusterRelationshipKindSchema = enumSchema(
-  ["seed", "preflight", "redirect", "retry", "duplicate", "follow-on"],
-  { title: "OpensteerObservationClusterRelationshipKind" }
-);
-var opensteerReverseReportKindSchema = enumSchema(
-  ["discovery", "package"],
-  { title: "OpensteerReverseReportKind" }
-);
-var opensteerReversePackageKindSchema = enumSchema(
-  ["portable-http", "browser-workflow"],
-  { title: "OpensteerReversePackageKind" }
-);
-var opensteerReversePackageReadinessSchema = enumSchema(
-  ["runnable", "draft", "unsupported"],
-  { title: "OpensteerReversePackageReadiness" }
-);
-var opensteerBodyCodecKindSchema = enumSchema(
-  [
-    "json",
-    "form-urlencoded",
-    "multipart",
-    "graphql",
-    "persisted-graphql",
-    "text",
-    "opaque-binary",
-    "sse",
-    "websocket-json",
-    "websocket-text",
-    "unknown"
-  ],
-  { title: "OpensteerBodyCodecKind" }
-);
-var opensteerExecutableResolverKindSchema = enumSchema(
-  [
-    "literal",
-    "cookie",
-    "storage",
-    "prior-record",
-    "binding",
-    "candidate",
-    "case",
-    "state-snapshot",
-    "artifact",
-    "manual",
-    "runtime-managed"
-  ],
-  { title: "OpensteerExecutableResolverKind" }
-);
-var opensteerValueReferenceKindSchema = enumSchema(
-  [
-    "literal",
-    "resolver",
-    "binding",
-    "candidate",
-    "case",
-    "record",
-    "artifact",
-    "state-snapshot",
-    "runtime",
-    "manual"
-  ],
-  { title: "OpensteerValueReferenceKind" }
-);
-var opensteerRuntimeValueKeySchema = enumSchema(
-  ["pageRef", "packageId", "caseId", "candidateId", "objective"],
-  { title: "OpensteerRuntimeValueKey" }
-);
-var opensteerValidationRuleKindSchema = enumSchema(
-  [
-    "status",
-    "json-structure",
-    "text-includes",
-    "stream-first-chunk",
-    "websocket-open",
-    "message-count-at-least"
-  ],
-  { title: "OpensteerValidationRuleKind" }
-);
-var opensteerReverseWorkflowStepKindSchema = enumSchema(
-  ["operation", "await-record", "assert"],
-  { title: "OpensteerReverseWorkflowStepKind" }
-);
-var opensteerReverseRequirementKindSchema = enumSchema(
-  ["resolver", "guard", "workflow-step", "state", "channel", "unsupported"],
-  { title: "OpensteerReverseRequirementKind" }
-);
-var opensteerReverseRequirementStatusSchema = enumSchema(
-  ["required", "recommended"],
-  { title: "OpensteerReverseRequirementStatus" }
-);
-var opensteerReverseSuggestedEditKindSchema = enumSchema(
-  [
-    "set-resolver",
-    "attach-trace",
-    "replace-workflow",
-    "patch-step-input",
-    "switch-state-source",
-    "inspect-evidence",
-    "mark-unsupported"
-  ],
-  { title: "OpensteerReverseSuggestedEditKind" }
-);
-var jsonValueSchema2 = defineSchema({
-  title: "JsonValue"
-});
-var opensteerValueReferenceSchema = objectSchema(
-  {
-    kind: opensteerValueReferenceKindSchema,
-    pointer: stringSchema({ minLength: 1 }),
-    resolverId: stringSchema({ minLength: 1 }),
-    binding: stringSchema({ minLength: 1 }),
-    recordId: stringSchema({ minLength: 1 }),
-    artifactId: stringSchema({ minLength: 1 }),
-    stateSnapshotId: stringSchema({ minLength: 1 }),
-    runtimeKey: opensteerRuntimeValueKeySchema,
-    value: jsonValueSchema2,
-    placeholder: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerValueReference",
-    required: ["kind"]
-  }
-);
-var opensteerValueTemplateSchema = defineSchema({
-  title: "OpensteerValueTemplate"
-});
-var opensteerReverseTargetHintsSchema = objectSchema(
-  {
-    hosts: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    paths: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    operationNames: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    channels: arraySchema(opensteerReverseChannelKindSchema, { uniqueItems: true })
-  },
-  {
-    title: "OpensteerReverseTargetHints"
-  }
-);
-var opensteerBodyCodecDescriptorSchema = objectSchema(
-  {
-    kind: opensteerBodyCodecKindSchema,
-    contentType: stringSchema({ minLength: 1 }),
-    operationName: stringSchema({ minLength: 1 }),
-    fieldPaths: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true })
-  },
-  {
-    title: "OpensteerBodyCodecDescriptor",
-    required: ["kind", "fieldPaths"]
-  }
-);
-var opensteerObservationClusterSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    observationId: stringSchema({ minLength: 1 }),
-    label: stringSchema({ minLength: 1 }),
-    channel: opensteerReverseChannelKindSchema,
-    method: stringSchema({ minLength: 1 }),
-    url: stringSchema({ minLength: 1 }),
-    matchedTargetHints: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    members: arraySchema(
-      objectSchema(
-        {
-          recordId: stringSchema({ minLength: 1 }),
-          observedAt: integerSchema({ minimum: 0 }),
-          resourceType: stringSchema({ minLength: 1 }),
-          status: integerSchema({ minimum: 0 }),
-          relation: opensteerObservationClusterRelationshipKindSchema,
-          relatedRecordId: stringSchema({ minLength: 1 }),
-          matchedTargetHints: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true })
-        },
-        {
-          title: "OpensteerObservationClusterMember",
-          required: ["recordId", "relation", "matchedTargetHints"]
-        }
-      )
-    )
-  },
-  {
-    title: "OpensteerObservationCluster",
-    required: ["id", "observationId", "label", "channel", "url", "matchedTargetHints", "members"]
-  }
-);
-var opensteerStateSnapshotCookieSchema = objectSchema(
-  {
-    name: stringSchema({ minLength: 1 }),
-    value: stringSchema(),
-    domain: stringSchema({ minLength: 1 }),
-    path: stringSchema({ minLength: 1 }),
-    secure: { type: "boolean" },
-    httpOnly: { type: "boolean" },
-    sameSite: enumSchema(["strict", "lax", "none"]),
-    priority: enumSchema(["low", "medium", "high"]),
-    partitionKey: stringSchema({ minLength: 1 }),
-    session: { type: "boolean" },
-    expiresAt: oneOfSchema([integerSchema({ minimum: 0 }), { type: "null" }])
-  },
-  {
-    title: "OpensteerStateSnapshotCookie",
-    required: ["name", "value", "domain", "path", "secure", "httpOnly", "session"]
-  }
-);
-var opensteerStateSnapshotSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    capturedAt: integerSchema({ minimum: 0 }),
-    pageRef: pageRefSchema,
-    url: stringSchema({ minLength: 1 }),
-    cookies: arraySchema(opensteerStateSnapshotCookieSchema),
-    storage: storageSnapshotSchema,
-    hiddenFields: arraySchema(
-      objectSchema(
-        {
-          path: stringSchema({ minLength: 1 }),
-          name: stringSchema({ minLength: 1 }),
-          value: stringSchema()
-        },
-        {
-          title: "OpensteerStateSnapshotHiddenField",
-          required: ["path", "name", "value"]
-        }
-      )
-    ),
-    globals: recordSchema({}, { title: "OpensteerStateSnapshotGlobals" })
-  },
-  {
-    title: "OpensteerStateSnapshot",
-    required: ["id", "capturedAt"]
-  }
-);
-var opensteerStateDeltaSchema = objectSchema(
-  {
-    beforeStateId: stringSchema({ minLength: 1 }),
-    afterStateId: stringSchema({ minLength: 1 }),
-    cookiesChanged: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    storageChanged: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    hiddenFieldsChanged: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    globalsChanged: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true })
-  },
-  {
-    title: "OpensteerStateDelta",
-    required: ["cookiesChanged", "storageChanged", "hiddenFieldsChanged", "globalsChanged"]
-  }
-);
-var opensteerRequestInputDescriptorSchema = objectSchema(
-  {
-    name: stringSchema({ minLength: 1 }),
-    location: opensteerRequestInputLocationSchema,
-    path: stringSchema({ minLength: 1 }),
-    wireName: stringSchema({ minLength: 1 }),
-    requiredness: opensteerRequestInputRequirednessSchema,
-    classification: opensteerRequestInputClassificationSchema,
-    source: opensteerRequestInputSourceSchema,
-    materializationPolicy: opensteerRequestInputMaterializationPolicySchema,
-    exportPolicy: opensteerRequestInputExportPolicySchema,
-    originalValue: stringSchema(),
-    provenance: objectSchema(
-      {
-        recordId: stringSchema({ minLength: 1 }),
-        observationId: stringSchema({ minLength: 1 }),
-        sourcePointer: stringSchema({ minLength: 1 }),
-        notes: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerRequestInputDescriptorProvenance"
-      }
-    ),
-    unlockedByGuardIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true })
-  },
-  {
-    title: "OpensteerRequestInputDescriptor",
-    required: [
-      "name",
-      "location",
-      "requiredness",
-      "classification",
-      "source",
-      "materializationPolicy",
-      "exportPolicy"
-    ]
-  }
-);
-var opensteerExecutableResolverSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    kind: opensteerExecutableResolverKindSchema,
-    label: stringSchema({ minLength: 1 }),
-    status: enumSchema(["ready", "missing"]),
-    requiresBrowser: { type: "boolean" },
-    requiresLiveState: { type: "boolean" },
-    description: stringSchema({ minLength: 1 }),
-    inputNames: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    guardId: stringSchema({ minLength: 1 }),
-    traceId: stringSchema({ minLength: 1 }),
-    valueRef: opensteerValueReferenceSchema
-  },
-  {
-    title: "OpensteerExecutableResolver",
-    required: ["id", "kind", "label", "status", "requiresBrowser", "requiresLiveState"]
-  }
-);
-var opensteerReverseAdvisorySignalsSchema = objectSchema(
-  {
-    advisoryRank: numberSchema(),
-    observedAt: integerSchema({ minimum: 0 }),
-    targetHintMatches: integerSchema({ minimum: 0 }),
-    responseRichness: integerSchema({ minimum: 0 }),
-    portabilityWeight: integerSchema({ minimum: 0 }),
-    boundaryWeight: integerSchema({ minimum: 0 }),
-    successfulStatus: { type: "boolean" },
-    fetchLike: { type: "boolean" },
-    hasResponseBody: { type: "boolean" },
-    dataPathMatch: { type: "boolean" },
-    cookieInputCount: integerSchema({ minimum: 0 }),
-    storageInputCount: integerSchema({ minimum: 0 }),
-    volatileInputCount: integerSchema({ minimum: 0 }),
-    guardCount: integerSchema({ minimum: 0 })
-  },
-  {
-    title: "OpensteerReverseAdvisorySignals",
-    required: [
-      "advisoryRank",
-      "targetHintMatches",
-      "responseRichness",
-      "portabilityWeight",
-      "boundaryWeight",
-      "successfulStatus",
-      "fetchLike",
-      "hasResponseBody",
-      "dataPathMatch",
-      "cookieInputCount",
-      "storageInputCount",
-      "volatileInputCount",
-      "guardCount"
-    ]
-  }
-);
-var opensteerValidationRuleSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    kind: opensteerValidationRuleKindSchema,
-    label: stringSchema({ minLength: 1 }),
-    required: { type: "boolean" },
-    expectedStatus: integerSchema({ minimum: 0 }),
-    structureHash: stringSchema({ minLength: 1 }),
-    textIncludes: stringSchema({ minLength: 1 }),
-    minimumCount: integerSchema({ minimum: 0 })
-  },
-  {
-    title: "OpensteerValidationRule",
-    required: ["id", "kind", "label", "required"]
-  }
-);
-var opensteerChannelDescriptorSchema = objectSchema(
-  {
-    kind: opensteerReverseChannelKindSchema,
-    recordKind: networkRecordKindSchema,
-    method: stringSchema({ minLength: 1 }),
-    url: stringSchema({ minLength: 1 }),
-    subprotocol: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerChannelDescriptor",
-    required: ["kind", "recordKind", "url"]
-  }
-);
-var opensteerReverseOperationWorkflowStepSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    kind: enumSchema(["operation"]),
-    label: stringSchema({ minLength: 1 }),
-    operation: stringSchema({ minLength: 1 }),
-    input: opensteerValueTemplateSchema,
-    bindAs: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerReverseOperationWorkflowStep",
-    required: ["id", "kind", "label", "operation", "input"]
-  }
-);
-var opensteerReverseAwaitRecordWorkflowStepSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    kind: enumSchema(["await-record"]),
-    label: stringSchema({ minLength: 1 }),
-    channel: opensteerChannelDescriptorSchema,
-    recordId: stringSchema({ minLength: 1 }),
-    match: objectSchema(
-      {
-        recordId: stringSchema({ minLength: 1 }),
-        host: stringSchema({ minLength: 1 }),
-        path: stringSchema({ minLength: 1 }),
-        method: stringSchema({ minLength: 1 }),
-        channel: opensteerReverseChannelKindSchema,
-        status: integerSchema({ minimum: 0 }),
-        text: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerReverseAwaitRecordMatch"
-      }
-    ),
-    validationRuleIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    timeoutMs: integerSchema({ minimum: 0 }),
-    bindAs: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerReverseAwaitRecordWorkflowStep",
-    required: ["id", "kind", "label", "channel"]
-  }
-);
-var opensteerReverseAssertWorkflowStepSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    kind: enumSchema(["assert"]),
-    label: stringSchema({ minLength: 1 }),
-    validationRuleIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    binding: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerReverseAssertWorkflowStep",
-    required: ["id", "kind", "label", "validationRuleIds"]
-  }
-);
-var opensteerReverseWorkflowStepSchema = oneOfSchema(
-  [
-    opensteerReverseOperationWorkflowStepSchema,
-    opensteerReverseAwaitRecordWorkflowStepSchema,
-    opensteerReverseAssertWorkflowStepSchema
-  ],
-  {
-    title: "OpensteerReverseWorkflowStep"
-  }
-);
-var opensteerReversePackageRequirementsSchema = objectSchema(
-  {
-    requiresBrowser: { type: "boolean" },
-    requiresLiveState: { type: "boolean" },
-    manualCalibration: enumSchema(["not-needed", "recommended", "required"]),
-    stateSources: arraySchema(opensteerStateSourceKindSchema, { uniqueItems: true })
-  },
-  {
-    title: "OpensteerReversePackageRequirements",
-    required: ["requiresBrowser", "requiresLiveState", "manualCalibration", "stateSources"]
-  }
-);
-var opensteerReverseAdvisoryTemplateSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    label: stringSchema({ minLength: 1 }),
-    channel: opensteerReverseChannelKindSchema,
-    execution: enumSchema(["transport", "page-observation"]),
-    stateSource: opensteerStateSourceKindSchema,
-    observationId: stringSchema({ minLength: 1 }),
-    transport: transportKindSchema,
-    guardIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    resolverIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    requiresBrowser: { type: "boolean" },
-    requiresLiveState: { type: "boolean" },
-    viability: enumSchema(["ready", "draft", "unsupported"]),
-    notes: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerReverseAdvisoryTemplate",
-    required: [
-      "id",
-      "label",
-      "channel",
-      "execution",
-      "stateSource",
-      "guardIds",
-      "resolverIds",
-      "requiresBrowser",
-      "requiresLiveState",
-      "viability"
-    ]
-  }
-);
-var opensteerReverseGuardRecordSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    kind: enumSchema(["interaction", "state", "script", "manual"]),
-    label: stringSchema({ minLength: 1 }),
-    status: enumSchema(["required", "satisfied", "unresolved"]),
-    interactionTraceId: stringSchema({ minLength: 1 }),
-    notes: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerReverseGuardRecord",
-    required: ["id", "kind", "label", "status"]
-  }
-);
-var opensteerReverseObservationRecordSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    capturedAt: integerSchema({ minimum: 0 }),
-    pageRef: pageRefSchema,
-    url: stringSchema({ minLength: 1 }),
-    stateSource: opensteerStateSourceKindSchema,
-    networkRecordIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    scriptArtifactIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    interactionTraceIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    stateSnapshotIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    notes: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerReverseObservationRecord",
-    required: [
-      "id",
-      "capturedAt",
-      "stateSource",
-      "networkRecordIds",
-      "scriptArtifactIds",
-      "interactionTraceIds",
-      "stateSnapshotIds"
-    ]
-  }
-);
-var opensteerReverseObservedRecordSchema = objectSchema(
-  {
-    recordId: stringSchema({ minLength: 1 }),
-    observationId: stringSchema({ minLength: 1 }),
-    clusterId: stringSchema({ minLength: 1 }),
-    observedAt: integerSchema({ minimum: 0 }),
-    channel: opensteerChannelDescriptorSchema,
-    bodyCodec: opensteerBodyCodecDescriptorSchema,
-    resourceType: stringSchema({ minLength: 1 }),
-    status: integerSchema({ minimum: 0 }),
-    matchedTargetHints: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    relationKinds: arraySchema(opensteerObservationClusterRelationshipKindSchema, {
-      uniqueItems: true
-    })
-  },
-  {
-    title: "OpensteerReverseObservedRecord",
-    required: [
-      "recordId",
-      "observationId",
-      "clusterId",
-      "channel",
-      "bodyCodec",
-      "matchedTargetHints",
-      "relationKinds"
-    ]
-  }
-);
-var opensteerReverseCandidateRecordSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    observationId: stringSchema({ minLength: 1 }),
-    clusterId: stringSchema({ minLength: 1 }),
-    recordId: stringSchema({ minLength: 1 }),
-    channel: opensteerChannelDescriptorSchema,
-    bodyCodec: opensteerBodyCodecDescriptorSchema,
-    boundary: opensteerReverseCandidateBoundarySchema,
-    summary: stringSchema({ minLength: 1 }),
-    matchedTargetHints: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    advisoryTags: arraySchema(opensteerReverseAdvisoryTagSchema, { uniqueItems: true }),
-    constraints: arraySchema(opensteerReverseConstraintKindSchema, { uniqueItems: true }),
-    signals: opensteerReverseAdvisorySignalsSchema,
-    inputs: arraySchema(opensteerRequestInputDescriptorSchema),
-    resolvers: arraySchema(opensteerExecutableResolverSchema),
-    guardIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    scriptArtifactIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    advisoryTemplates: arraySchema(opensteerReverseAdvisoryTemplateSchema)
-  },
-  {
-    title: "OpensteerReverseCandidateRecord",
-    required: [
-      "id",
-      "observationId",
-      "clusterId",
-      "recordId",
-      "channel",
-      "bodyCodec",
-      "boundary",
-      "summary",
-      "matchedTargetHints",
-      "advisoryTags",
-      "constraints",
-      "signals",
-      "inputs",
-      "resolvers",
-      "guardIds",
-      "scriptArtifactIds",
-      "advisoryTemplates"
-    ]
-  }
-);
-var opensteerReverseReplayValidationSchema = objectSchema(
-  {
-    statusMatches: { type: "boolean" },
-    structureMatches: { type: "boolean" },
-    opened: { type: "boolean" },
-    firstChunkObserved: { type: "boolean" },
-    firstChunkMatches: { type: "boolean" },
-    messageObserved: { type: "boolean" },
-    messageCount: integerSchema({ minimum: 0 })
-  },
-  {
-    title: "OpensteerReverseReplayValidation"
-  }
-);
-var opensteerReverseReplayRunRecordSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    createdAt: integerSchema({ minimum: 0 }),
-    candidateId: stringSchema({ minLength: 1 }),
-    templateId: stringSchema({ minLength: 1 }),
-    packageId: stringSchema({ minLength: 1 }),
-    success: { type: "boolean" },
-    channel: opensteerReverseChannelKindSchema,
-    kind: opensteerReversePackageKindSchema,
-    readiness: opensteerReversePackageReadinessSchema,
-    transport: transportKindSchema,
-    stateSource: opensteerStateSourceKindSchema,
-    executedStepIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    failedStepId: stringSchema({ minLength: 1 }),
-    bindings: recordSchema({}, { title: "OpensteerReverseReplayRunBindings" }),
-    recordId: stringSchema({ minLength: 1 }),
-    status: integerSchema({ minimum: 0 }),
-    validation: opensteerReverseReplayValidationSchema,
-    error: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerReverseReplayRunRecord",
-    required: [
-      "id",
-      "createdAt",
-      "packageId",
-      "success",
-      "kind",
-      "readiness",
-      "executedStepIds",
-      "validation"
-    ]
-  }
-);
-var opensteerReverseExperimentRecordSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    createdAt: integerSchema({ minimum: 0 }),
-    candidateId: stringSchema({ minLength: 1 }),
-    templateId: stringSchema({ minLength: 1 }),
-    kind: enumSchema(["replay-attempt", "field-variation"]),
-    hypothesis: stringSchema({ minLength: 1 }),
-    success: { type: "boolean" },
-    status: integerSchema({ minimum: 0 }),
-    notes: stringSchema({ minLength: 1 }),
-    validation: opensteerReverseReplayValidationSchema
-  },
-  {
-    title: "OpensteerReverseExperimentRecord",
-    required: ["id", "createdAt", "kind", "hypothesis", "success"]
-  }
-);
-var opensteerReverseRequirementSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    kind: opensteerReverseRequirementKindSchema,
-    status: opensteerReverseRequirementStatusSchema,
-    label: stringSchema({ minLength: 1 }),
-    description: stringSchema({ minLength: 1 }),
-    blocking: { type: "boolean" },
-    resolverId: stringSchema({ minLength: 1 }),
-    guardId: stringSchema({ minLength: 1 }),
-    stepId: stringSchema({ minLength: 1 }),
-    inputNames: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    traceId: stringSchema({ minLength: 1 }),
-    artifactId: stringSchema({ minLength: 1 }),
-    recordId: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerReverseRequirement",
-    required: ["id", "kind", "status", "label", "blocking"]
-  }
-);
-var opensteerReverseSuggestedEditSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    kind: opensteerReverseSuggestedEditKindSchema,
-    label: stringSchema({ minLength: 1 }),
-    description: stringSchema({ minLength: 1 }),
-    resolverId: stringSchema({ minLength: 1 }),
-    guardId: stringSchema({ minLength: 1 }),
-    stepId: stringSchema({ minLength: 1 }),
-    traceId: stringSchema({ minLength: 1 }),
-    artifactId: stringSchema({ minLength: 1 }),
-    recordId: stringSchema({ minLength: 1 }),
-    payload: jsonValueSchema2
-  },
-  {
-    title: "OpensteerReverseSuggestedEdit",
-    required: ["id", "kind", "label"]
-  }
-);
-var opensteerReverseExportRecordSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    createdAt: integerSchema({ minimum: 0 }),
-    candidateId: stringSchema({ minLength: 1 }),
-    templateId: stringSchema({ minLength: 1 }),
-    packageId: stringSchema({ minLength: 1 }),
-    kind: opensteerReversePackageKindSchema,
-    readiness: opensteerReversePackageReadinessSchema,
-    requestPlanId: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerReverseExportRecord",
-    required: ["id", "createdAt", "packageId", "kind", "readiness"]
-  }
-);
-var opensteerReverseCasePayloadSchema = objectSchema(
-  {
-    objective: stringSchema({ minLength: 1 }),
-    notes: stringSchema({ minLength: 1 }),
-    status: opensteerReverseCaseStatusSchema,
-    stateSource: opensteerStateSourceKindSchema,
-    observations: arraySchema(opensteerReverseObservationRecordSchema),
-    observationClusters: arraySchema(opensteerObservationClusterSchema),
-    observedRecords: arraySchema(opensteerReverseObservedRecordSchema),
-    candidates: arraySchema(opensteerReverseCandidateRecordSchema),
-    guards: arraySchema(opensteerReverseGuardRecordSchema),
-    stateSnapshots: arraySchema(opensteerStateSnapshotSchema),
-    stateDeltas: arraySchema(opensteerStateDeltaSchema),
-    experiments: arraySchema(opensteerReverseExperimentRecordSchema),
-    replayRuns: arraySchema(opensteerReverseReplayRunRecordSchema),
-    exports: arraySchema(opensteerReverseExportRecordSchema)
-  },
-  {
-    title: "OpensteerReverseCasePayload",
-    required: [
-      "objective",
-      "status",
-      "stateSource",
-      "observations",
-      "observationClusters",
-      "observedRecords",
-      "candidates",
-      "guards",
-      "stateSnapshots",
-      "stateDeltas",
-      "experiments",
-      "replayRuns",
-      "exports"
-    ]
-  }
-);
-var opensteerReverseCaseRecordSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    key: stringSchema({ minLength: 1 }),
-    version: stringSchema({ minLength: 1 }),
-    createdAt: integerSchema({ minimum: 0 }),
-    updatedAt: integerSchema({ minimum: 0 }),
-    contentHash: stringSchema({ minLength: 1 }),
-    tags: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    provenance: opensteerRegistryProvenanceSchema,
-    payload: opensteerReverseCasePayloadSchema
-  },
-  {
-    title: "OpensteerReverseCaseRecord",
-    required: ["id", "key", "version", "createdAt", "updatedAt", "contentHash", "tags", "payload"]
-  }
-);
-var opensteerReversePackagePayloadSchema = objectSchema(
-  {
-    kind: opensteerReversePackageKindSchema,
-    readiness: opensteerReversePackageReadinessSchema,
-    caseId: stringSchema({ minLength: 1 }),
-    objective: stringSchema({ minLength: 1 }),
-    source: objectSchema(
-      {
-        kind: enumSchema(["record", "candidate"]),
-        id: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerReversePackageSource",
-        required: ["kind", "id"]
-      }
-    ),
-    sourceRecordId: stringSchema({ minLength: 1 }),
-    candidateId: stringSchema({ minLength: 1 }),
-    candidate: opensteerReverseCandidateRecordSchema,
-    templateId: stringSchema({ minLength: 1 }),
-    template: opensteerReverseAdvisoryTemplateSchema,
-    channel: opensteerChannelDescriptorSchema,
-    stateSource: opensteerStateSourceKindSchema,
-    observationId: stringSchema({ minLength: 1 }),
-    transport: transportKindSchema,
-    guardIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    workflow: arraySchema(opensteerReverseWorkflowStepSchema),
-    resolvers: arraySchema(opensteerExecutableResolverSchema),
-    validators: arraySchema(opensteerValidationRuleSchema),
-    stateSnapshots: arraySchema(opensteerStateSnapshotSchema),
-    requirements: opensteerReversePackageRequirementsSchema,
-    requestPlanId: stringSchema({ minLength: 1 }),
-    unresolvedRequirements: arraySchema(opensteerReverseRequirementSchema),
-    suggestedEdits: arraySchema(opensteerReverseSuggestedEditSchema),
-    attachedTraceIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    attachedArtifactIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    attachedRecordIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    notes: stringSchema({ minLength: 1 }),
-    parentPackageId: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerReversePackagePayload",
-    required: [
-      "kind",
-      "readiness",
-      "caseId",
-      "objective",
-      "source",
-      "sourceRecordId",
-      "guardIds",
-      "workflow",
-      "resolvers",
-      "validators",
-      "stateSnapshots",
-      "requirements",
-      "unresolvedRequirements",
-      "suggestedEdits",
-      "attachedTraceIds",
-      "attachedArtifactIds",
-      "attachedRecordIds"
-    ]
-  }
-);
-var opensteerReversePackageRecordSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    key: stringSchema({ minLength: 1 }),
-    version: stringSchema({ minLength: 1 }),
-    createdAt: integerSchema({ minimum: 0 }),
-    updatedAt: integerSchema({ minimum: 0 }),
-    contentHash: stringSchema({ minLength: 1 }),
-    tags: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    provenance: opensteerRegistryProvenanceSchema,
-    payload: opensteerReversePackagePayloadSchema
-  },
-  {
-    title: "OpensteerReversePackageRecord",
-    required: ["id", "key", "version", "createdAt", "updatedAt", "contentHash", "tags", "payload"]
-  }
-);
-var opensteerReverseCandidateReportItemSchema = objectSchema(
-  {
-    candidateId: stringSchema({ minLength: 1 }),
-    clusterId: stringSchema({ minLength: 1 }),
-    advisoryRank: numberSchema(),
-    bodyCodec: opensteerBodyCodecDescriptorSchema,
-    summary: stringSchema({ minLength: 1 }),
-    advisoryTags: arraySchema(opensteerReverseAdvisoryTagSchema, { uniqueItems: true }),
-    constraints: arraySchema(opensteerReverseConstraintKindSchema, { uniqueItems: true }),
-    signals: opensteerReverseAdvisorySignalsSchema,
-    reasons: arraySchema(stringSchema({ minLength: 1 }))
-  },
-  {
-    title: "OpensteerReverseCandidateAdvisoryItem",
-    required: [
-      "candidateId",
-      "clusterId",
-      "advisoryRank",
-      "bodyCodec",
-      "summary",
-      "advisoryTags",
-      "constraints",
-      "signals",
-      "reasons"
-    ]
-  }
-);
-var opensteerReverseDiscoverySummaryCountsSchema = objectSchema(
-  {
-    hosts: recordSchema(integerSchema({ minimum: 0 }), { title: "OpensteerReverseSummaryHosts" }),
-    channels: recordSchema(integerSchema({ minimum: 0 }), {
-      title: "OpensteerReverseSummaryChannels"
-    }),
-    resourceTypes: recordSchema(integerSchema({ minimum: 0 }), {
-      title: "OpensteerReverseSummaryResourceTypes"
-    }),
-    advisoryTags: recordSchema(integerSchema({ minimum: 0 }), {
-      title: "OpensteerReverseSummaryAdvisoryTags"
-    }),
-    constraints: recordSchema(integerSchema({ minimum: 0 }), {
-      title: "OpensteerReverseSummaryConstraints"
-    }),
-    relationKinds: recordSchema(integerSchema({ minimum: 0 }), {
-      title: "OpensteerReverseSummaryRelationKinds"
-    })
-  },
-  {
-    title: "OpensteerReverseDiscoverySummaryCounts",
-    required: [
-      "hosts",
-      "channels",
-      "resourceTypes",
-      "advisoryTags",
-      "constraints",
-      "relationKinds"
-    ]
-  }
-);
-var opensteerReverseReportPayloadSchema = objectSchema(
-  {
-    kind: opensteerReverseReportKindSchema,
-    caseId: stringSchema({ minLength: 1 }),
-    objective: stringSchema({ minLength: 1 }),
-    packageId: stringSchema({ minLength: 1 }),
-    packageKind: opensteerReversePackageKindSchema,
-    packageReadiness: opensteerReversePackageReadinessSchema,
-    observations: arraySchema(opensteerReverseObservationRecordSchema),
-    observationClusters: arraySchema(opensteerObservationClusterSchema),
-    observedRecords: arraySchema(opensteerReverseObservedRecordSchema),
-    guards: arraySchema(opensteerReverseGuardRecordSchema),
-    stateDeltas: arraySchema(opensteerStateDeltaSchema),
-    summaryCounts: opensteerReverseDiscoverySummaryCountsSchema,
-    candidateAdvisories: arraySchema(opensteerReverseCandidateReportItemSchema),
-    query: objectSchema(
-      {
-        view: opensteerReverseQueryViewSchema,
-        filters: objectSchema(
-          {
-            recordId: stringSchema({ minLength: 1 }),
-            clusterId: stringSchema({ minLength: 1 }),
-            candidateId: stringSchema({ minLength: 1 }),
-            host: stringSchema({ minLength: 1 }),
-            path: stringSchema({ minLength: 1 }),
-            method: stringSchema({ minLength: 1 }),
-            status: stringSchema({ minLength: 1 }),
-            resourceType: stringSchema({ minLength: 1 }),
-            channel: opensteerReverseChannelKindSchema,
-            boundary: opensteerReverseCandidateBoundarySchema,
-            advisoryTag: opensteerReverseAdvisoryTagSchema,
-            constraint: opensteerReverseConstraintKindSchema,
-            bodyCodec: opensteerBodyCodecKindSchema,
-            relationKind: opensteerObservationClusterRelationshipKindSchema,
-            hasGuards: { type: "boolean" },
-            hasResolvers: { type: "boolean" },
-            artifactId: stringSchema({ minLength: 1 }),
-            stateSnapshotId: stringSchema({ minLength: 1 }),
-            traceId: stringSchema({ minLength: 1 }),
-            evidenceRef: stringSchema({ minLength: 1 }),
-            text: stringSchema({ minLength: 1 })
-          },
-          {
-            title: "OpensteerReverseReportQueryFilters"
-          }
-        ),
-        sort: objectSchema(
-          {
-            preset: opensteerReverseSortPresetSchema,
-            keys: arraySchema(
-              objectSchema(
-                {
-                  key: opensteerReverseSortKeySchema,
-                  direction: opensteerReverseSortDirectionSchema
-                },
-                {
-                  title: "OpensteerReverseReportQuerySortTerm",
-                  required: ["key"]
-                }
-              ),
-              { minItems: 1 }
-            )
-          },
-          {
-            title: "OpensteerReverseReportQuerySort"
-          }
-        ),
-        limit: integerSchema({ minimum: 1 }),
-        totalCount: integerSchema({ minimum: 0 }),
-        nextCursor: stringSchema({ minLength: 1 }),
-        resultIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true })
-      },
-      {
-        title: "OpensteerReverseQuerySnapshot",
-        required: ["view", "sort", "limit", "totalCount", "resultIds"]
-      }
-    ),
-    experiments: arraySchema(opensteerReverseExperimentRecordSchema),
-    replayRuns: arraySchema(opensteerReverseReplayRunRecordSchema),
-    unresolvedRequirements: arraySchema(opensteerReverseRequirementSchema),
-    suggestedEdits: arraySchema(opensteerReverseSuggestedEditSchema),
-    linkedNetworkRecordIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    linkedInteractionTraceIds: arraySchema(stringSchema({ minLength: 1 }), {
-      uniqueItems: true
-    }),
-    linkedArtifactIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    linkedStateSnapshotIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    package: opensteerReversePackageRecordSchema
-  },
-  {
-    title: "OpensteerReverseReportPayload",
-    required: [
-      "kind",
-      "caseId",
-      "objective",
-      "observations",
-      "observationClusters",
-      "observedRecords",
-      "guards",
-      "stateDeltas",
-      "summaryCounts",
-      "candidateAdvisories",
-      "experiments",
-      "replayRuns",
-      "linkedNetworkRecordIds",
-      "linkedInteractionTraceIds",
-      "linkedArtifactIds",
-      "linkedStateSnapshotIds"
-    ]
-  }
-);
-var opensteerReverseReportRecordSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    key: stringSchema({ minLength: 1 }),
-    version: stringSchema({ minLength: 1 }),
-    createdAt: integerSchema({ minimum: 0 }),
-    updatedAt: integerSchema({ minimum: 0 }),
-    contentHash: stringSchema({ minLength: 1 }),
-    tags: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    provenance: opensteerRegistryProvenanceSchema,
-    payload: opensteerReverseReportPayloadSchema
-  },
-  {
-    title: "OpensteerReverseReportRecord",
-    required: ["id", "key", "version", "createdAt", "updatedAt", "contentHash", "tags", "payload"]
-  }
-);
-var opensteerReverseNetworkFilterSchema = objectSchema(
-  {
-    url: stringSchema({ minLength: 1 }),
-    hostname: stringSchema({ minLength: 1 }),
-    path: stringSchema({ minLength: 1 }),
-    method: stringSchema({ minLength: 1 }),
-    resourceType: stringSchema({ minLength: 1 }),
-    includeBodies: { type: "boolean" }
-  },
-  {
-    title: "OpensteerReverseCaptureNetworkFilter"
-  }
-);
-var opensteerReverseQueryFiltersSchema = objectSchema(
-  {
-    recordId: stringSchema({ minLength: 1 }),
-    clusterId: stringSchema({ minLength: 1 }),
-    candidateId: stringSchema({ minLength: 1 }),
-    host: stringSchema({ minLength: 1 }),
-    path: stringSchema({ minLength: 1 }),
-    method: stringSchema({ minLength: 1 }),
-    status: stringSchema({ minLength: 1 }),
-    resourceType: stringSchema({ minLength: 1 }),
-    channel: opensteerReverseChannelKindSchema,
-    boundary: opensteerReverseCandidateBoundarySchema,
-    advisoryTag: opensteerReverseAdvisoryTagSchema,
-    constraint: opensteerReverseConstraintKindSchema,
-    bodyCodec: opensteerBodyCodecKindSchema,
-    relationKind: opensteerObservationClusterRelationshipKindSchema,
-    hasGuards: { type: "boolean" },
-    hasResolvers: { type: "boolean" },
-    artifactId: stringSchema({ minLength: 1 }),
-    stateSnapshotId: stringSchema({ minLength: 1 }),
-    traceId: stringSchema({ minLength: 1 }),
-    evidenceRef: stringSchema({ minLength: 1 }),
-    text: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerReverseQueryFilters"
-  }
-);
-var opensteerReverseQuerySortSchema = objectSchema(
-  {
-    preset: opensteerReverseSortPresetSchema,
-    keys: arraySchema(
-      objectSchema(
-        {
-          key: opensteerReverseSortKeySchema,
-          direction: opensteerReverseSortDirectionSchema
-        },
-        {
-          title: "OpensteerReverseSortTerm",
-          required: ["key"]
-        }
-      ),
-      { minItems: 1 }
-    )
-  },
-  {
-    title: "OpensteerReverseQuerySort"
-  }
-);
-var opensteerReverseQuerySnapshotSchema = objectSchema(
-  {
-    view: opensteerReverseQueryViewSchema,
-    filters: opensteerReverseQueryFiltersSchema,
-    sort: opensteerReverseQuerySortSchema,
-    limit: integerSchema({ minimum: 1, maximum: 200 }),
-    totalCount: integerSchema({ minimum: 0 }),
-    nextCursor: stringSchema({ minLength: 1 }),
-    resultIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true })
-  },
-  {
-    title: "OpensteerReverseQuerySnapshot",
-    required: ["view", "sort", "limit", "totalCount", "resultIds"]
-  }
-);
-var opensteerReverseQueryRecordItemSchema = objectSchema(
-  {
-    record: opensteerReverseObservedRecordSchema,
-    candidateIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true })
-  },
-  {
-    title: "OpensteerReverseQueryRecordItem",
-    required: ["record", "candidateIds"]
-  }
-);
-var opensteerReverseQueryClusterItemSchema = objectSchema(
-  {
-    cluster: opensteerObservationClusterSchema,
-    candidateIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true })
-  },
-  {
-    title: "OpensteerReverseQueryClusterItem",
-    required: ["cluster", "candidateIds"]
-  }
-);
-var opensteerReverseQueryCandidateItemSchema = objectSchema(
-  {
-    candidate: opensteerReverseCandidateRecordSchema,
-    reasons: arraySchema(stringSchema({ minLength: 1 }))
-  },
-  {
-    title: "OpensteerReverseQueryCandidateItem",
-    required: ["candidate", "reasons"]
-  }
-);
-var opensteerReverseDiscoverInputSchema = objectSchema(
-  {
-    caseId: stringSchema({ minLength: 1 }),
-    key: stringSchema({ minLength: 1 }),
-    objective: stringSchema({ minLength: 1 }),
-    notes: stringSchema({ minLength: 1 }),
-    tags: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    pageRef: pageRefSchema,
-    stateSource: opensteerStateSourceKindSchema,
-    network: opensteerReverseNetworkFilterSchema,
-    includeScripts: { type: "boolean" },
-    includeStorage: { type: "boolean" },
-    includeSessionStorage: { type: "boolean" },
-    includeIndexedDb: { type: "boolean" },
-    interactionTraceIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    targetHints: opensteerReverseTargetHintsSchema,
-    captureWindowMs: integerSchema({ minimum: 0 }),
-    manualCalibration: opensteerReverseManualCalibrationModeSchema
-  },
-  {
-    title: "OpensteerReverseDiscoverInput"
-  }
-);
-var opensteerReverseDiscoverOutputSchema = objectSchema(
-  {
-    caseId: stringSchema({ minLength: 1 }),
-    reportId: stringSchema({ minLength: 1 }),
-    summary: objectSchema(
-      {
-        observationIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        recordCount: integerSchema({ minimum: 0 }),
-        clusterCount: integerSchema({ minimum: 0 }),
-        candidateCount: integerSchema({ minimum: 0 })
-      },
-      {
-        title: "OpensteerReverseDiscoverSummary",
-        required: ["observationIds", "recordCount", "clusterCount", "candidateCount"]
-      }
-    ),
-    index: objectSchema(
-      {
-        views: arraySchema(opensteerReverseQueryViewSchema, { uniqueItems: true }),
-        sortableKeys: arraySchema(opensteerReverseSortKeySchema, { uniqueItems: true }),
-        channels: arraySchema(opensteerReverseChannelKindSchema, { uniqueItems: true }),
-        hosts: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        relationKinds: arraySchema(opensteerObservationClusterRelationshipKindSchema, {
-          uniqueItems: true
-        })
-      },
-      {
-        title: "OpensteerReverseDiscoverIndex",
-        required: ["views", "sortableKeys", "channels", "hosts", "relationKinds"]
-      }
-    )
-  },
-  {
-    title: "OpensteerReverseDiscoverOutput",
-    required: ["caseId", "reportId", "summary", "index"]
-  }
-);
-var opensteerReverseQueryInputSchema = objectSchema(
-  {
-    caseId: stringSchema({ minLength: 1 }),
-    view: opensteerReverseQueryViewSchema,
-    filters: opensteerReverseQueryFiltersSchema,
-    sort: opensteerReverseQuerySortSchema,
-    limit: integerSchema({ minimum: 1, maximum: 200 }),
-    cursor: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerReverseQueryInput",
-    required: ["caseId"]
-  }
-);
-var opensteerReverseQueryOutputSchema = objectSchema(
-  {
-    caseId: stringSchema({ minLength: 1 }),
-    view: opensteerReverseQueryViewSchema,
-    query: opensteerReverseQuerySnapshotSchema,
-    totalCount: integerSchema({ minimum: 0 }),
-    nextCursor: stringSchema({ minLength: 1 }),
-    records: arraySchema(opensteerReverseQueryRecordItemSchema),
-    clusters: arraySchema(opensteerReverseQueryClusterItemSchema),
-    candidates: arraySchema(opensteerReverseQueryCandidateItemSchema)
-  },
-  {
-    title: "OpensteerReverseQueryOutput",
-    required: ["caseId", "view", "query", "totalCount"]
-  }
-);
-var opensteerReversePackageCreateInputSchema = objectSchema(
-  {
-    caseId: stringSchema({ minLength: 1 }),
-    source: objectSchema(
-      {
-        kind: enumSchema(["record", "candidate"]),
-        id: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerReversePackageCreateSource",
-        required: ["kind", "id"]
-      }
-    ),
-    templateId: stringSchema({ minLength: 1 }),
-    key: stringSchema({ minLength: 1 }),
-    version: stringSchema({ minLength: 1 }),
-    notes: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerReversePackageCreateInput",
-    required: ["caseId", "source"]
-  }
-);
-var opensteerReversePackageCreateOutputSchema = objectSchema(
-  {
-    package: opensteerReversePackageRecordSchema,
-    report: opensteerReverseReportRecordSchema
-  },
-  {
-    title: "OpensteerReversePackageCreateOutput",
-    required: ["package", "report"]
-  }
-);
-var opensteerReversePackageRunInputSchema = objectSchema(
-  {
-    packageId: stringSchema({ minLength: 1 }),
-    pageRef: pageRefSchema
-  },
-  {
-    title: "OpensteerReversePackageRunInput",
-    required: ["packageId"]
-  }
-);
-var opensteerReversePackageRunOutputSchema = objectSchema(
-  {
-    packageId: stringSchema({ minLength: 1 }),
-    caseId: stringSchema({ minLength: 1 }),
-    source: objectSchema(
-      {
-        kind: enumSchema(["record", "candidate"]),
-        id: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerReversePackageRunSource",
-        required: ["kind", "id"]
-      }
-    ),
-    candidateId: stringSchema({ minLength: 1 }),
-    templateId: stringSchema({ minLength: 1 }),
-    success: { type: "boolean" },
-    kind: opensteerReversePackageKindSchema,
-    readiness: opensteerReversePackageReadinessSchema,
-    channel: opensteerReverseChannelKindSchema,
-    transport: transportKindSchema,
-    stateSource: opensteerStateSourceKindSchema,
-    recordId: stringSchema({ minLength: 1 }),
-    status: integerSchema({ minimum: 0 }),
-    validation: opensteerReverseReplayValidationSchema,
-    executedStepIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    failedStepId: stringSchema({ minLength: 1 }),
-    bindings: recordSchema({}, { title: "OpensteerReversePackageRunBindings" }),
-    replayRunId: stringSchema({ minLength: 1 }),
-    unresolvedRequirements: arraySchema(opensteerReverseRequirementSchema),
-    suggestedEdits: arraySchema(opensteerReverseSuggestedEditSchema),
-    error: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerReversePackageRunOutput",
-    required: [
-      "packageId",
-      "source",
-      "success",
-      "kind",
-      "readiness",
-      "validation",
-      "executedStepIds",
-      "bindings",
-      "unresolvedRequirements",
-      "suggestedEdits"
-    ]
-  }
-);
-var opensteerReverseExportInputSchema = objectSchema(
-  {
-    packageId: stringSchema({ minLength: 1 }),
-    key: stringSchema({ minLength: 1 }),
-    version: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerReverseExportInput",
-    required: ["packageId"]
-  }
-);
-var opensteerReverseExportOutputSchema = objectSchema(
-  {
-    package: opensteerReversePackageRecordSchema,
-    requestPlan: opensteerRequestPlanRecordSchema
-  },
-  {
-    title: "OpensteerReverseExportOutput",
-    required: ["package"]
-  }
-);
-var opensteerReverseReportInputSchema = objectSchema(
-  {
-    caseId: stringSchema({ minLength: 1 }),
-    packageId: stringSchema({ minLength: 1 }),
-    reportId: stringSchema({ minLength: 1 }),
-    kind: opensteerReverseReportKindSchema
-  },
-  {
-    title: "OpensteerReverseReportInput"
-  }
-);
-var opensteerReverseReportOutputSchema = objectSchema(
-  {
-    report: opensteerReverseReportRecordSchema
-  },
-  {
-    title: "OpensteerReverseReportOutput",
-    required: ["report"]
-  }
-);
-var opensteerReversePackageGetInputSchema = objectSchema(
-  {
-    packageId: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerReversePackageGetInput",
-    required: ["packageId"]
-  }
-);
-var opensteerReversePackageGetOutputSchema = objectSchema(
-  {
-    package: opensteerReversePackageRecordSchema
-  },
-  {
-    title: "OpensteerReversePackageGetOutput",
-    required: ["package"]
-  }
-);
-var opensteerReversePackageListInputSchema = objectSchema(
-  {
-    caseId: stringSchema({ minLength: 1 }),
-    key: stringSchema({ minLength: 1 }),
-    kind: opensteerReversePackageKindSchema,
-    readiness: opensteerReversePackageReadinessSchema
-  },
-  {
-    title: "OpensteerReversePackageListInput"
-  }
-);
-var opensteerReversePackageListOutputSchema = objectSchema(
-  {
-    packages: arraySchema(opensteerReversePackageRecordSchema)
-  },
-  {
-    title: "OpensteerReversePackageListOutput",
-    required: ["packages"]
-  }
-);
-var opensteerReversePackagePatchInputSchema = objectSchema(
-  {
-    packageId: stringSchema({ minLength: 1 }),
-    key: stringSchema({ minLength: 1 }),
-    version: stringSchema({ minLength: 1 }),
-    notes: stringSchema({ minLength: 1 }),
-    workflow: arraySchema(opensteerReverseWorkflowStepSchema),
-    resolvers: arraySchema(opensteerExecutableResolverSchema),
-    validators: arraySchema(opensteerValidationRuleSchema),
-    attachedTraceIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    attachedArtifactIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    attachedRecordIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    stateSnapshotIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true })
-  },
-  {
-    title: "OpensteerReversePackagePatchInput",
-    required: ["packageId"]
-  }
-);
-var opensteerReversePackagePatchOutputSchema = objectSchema(
-  {
-    package: opensteerReversePackageRecordSchema,
-    report: opensteerReverseReportRecordSchema
-  },
-  {
-    title: "OpensteerReversePackagePatchOutput",
-    required: ["package", "report"]
-  }
-);
-
 // src/interaction.ts
 var opensteerInteractionEventRecordSchema = objectSchema(
   {
@@ -7112,12 +5174,12 @@ var opensteerDomExtractInputSchema = defineSchema({
   ),
   anyOf: [defineSchema({ required: ["persist"] }), defineSchema({ required: ["schema"] })]
 });
-var jsonValueSchema3 = recordSchema({}, { title: "JsonValueRecord" });
+var jsonValueSchema2 = recordSchema({}, { title: "JsonValueRecord" });
 var opensteerDomExtractOutputSchema = objectSchema(
   {
     data: oneOfSchema(
       [
-        jsonValueSchema3,
+        jsonValueSchema2,
         arraySchema({}),
         stringSchema(),
         numberSchema(),
@@ -7523,7 +5585,7 @@ var opensteerSemanticOperationSpecificationsBase = [
   }),
   defineSemanticOperationSpec({
     name: "artifact.read",
-    description: "Read a persisted artifact by ID so agents can inspect captured scripts, storage, cookies, or snapshots linked from reverse packages and reports.",
+    description: "Read a persisted artifact by ID so agents can inspect captured scripts, storage, cookies, or snapshots linked from recorded workflows.",
     inputSchema: opensteerArtifactReadInputSchema,
     outputSchema: opensteerArtifactReadOutputSchema,
     requiredCapabilities: []
@@ -7954,14 +6016,7 @@ exports.oneOfSchema = oneOfSchema;
 exports.opensteerArtifactReadInputSchema = opensteerArtifactReadInputSchema;
 exports.opensteerArtifactReadOutputSchema = opensteerArtifactReadOutputSchema;
 exports.opensteerArtifactSchema = opensteerArtifactSchema;
-exports.opensteerAuthRecipeHookRefSchema = opensteerAuthRecipeHookRefSchema;
-exports.opensteerAuthRecipePayloadSchema = opensteerAuthRecipePayloadSchema;
-exports.opensteerAuthRecipeRecordSchema = opensteerAuthRecipeRecordSchema;
-exports.opensteerAuthRecipeRefSchema = opensteerAuthRecipeRefSchema;
-exports.opensteerAuthRecipeStepSchema = opensteerAuthRecipeStepSchema;
 exports.opensteerAutomationOperationNames = opensteerAutomationOperationNames;
-exports.opensteerBodyCodecDescriptorSchema = opensteerBodyCodecDescriptorSchema;
-exports.opensteerBodyCodecKindSchema = opensteerBodyCodecKindSchema;
 exports.opensteerCapabilities = opensteerCapabilities;
 exports.opensteerCapabilityDescriptorListSchema = opensteerCapabilityDescriptorListSchema;
 exports.opensteerCapabilityDescriptorSchema = opensteerCapabilityDescriptorSchema;
@@ -7978,11 +6033,7 @@ exports.opensteerErrorCodes = opensteerErrorCodes;
 exports.opensteerErrorEnvelopeSchema = opensteerErrorEnvelopeSchema;
 exports.opensteerErrorSchema = opensteerErrorSchema;
 exports.opensteerEventSchema = opensteerEventSchema;
-exports.opensteerExecutableResolverKindSchema = opensteerExecutableResolverKindSchema;
-exports.opensteerExecutableResolverSchema = opensteerExecutableResolverSchema;
 exports.opensteerExposedSemanticOperationNames = opensteerExposedSemanticOperationNames;
-exports.opensteerGetAuthRecipeInputSchema = opensteerGetAuthRecipeInputSchema;
-exports.opensteerGetRecipeInputSchema = opensteerGetRecipeInputSchema;
 exports.opensteerGetRequestPlanInputSchema = opensteerGetRequestPlanInputSchema;
 exports.opensteerInferRequestPlanInputSchema = opensteerInferRequestPlanInputSchema;
 exports.opensteerInteractionCaptureInputSchema = opensteerInteractionCaptureInputSchema;
@@ -7996,10 +6047,6 @@ exports.opensteerInteractionReplayInputSchema = opensteerInteractionReplayInputS
 exports.opensteerInteractionReplayOutputSchema = opensteerInteractionReplayOutputSchema;
 exports.opensteerInteractionTracePayloadSchema = opensteerInteractionTracePayloadSchema;
 exports.opensteerInteractionTraceRecordSchema = opensteerInteractionTraceRecordSchema;
-exports.opensteerListAuthRecipesInputSchema = opensteerListAuthRecipesInputSchema;
-exports.opensteerListAuthRecipesOutputSchema = opensteerListAuthRecipesOutputSchema;
-exports.opensteerListRecipesInputSchema = opensteerListRecipesInputSchema;
-exports.opensteerListRecipesOutputSchema = opensteerListRecipesOutputSchema;
 exports.opensteerListRequestPlansInputSchema = opensteerListRequestPlansInputSchema;
 exports.opensteerListRequestPlansOutputSchema = opensteerListRequestPlansOutputSchema;
 exports.opensteerMcpTools = opensteerMcpTools;
@@ -8013,8 +6060,6 @@ exports.opensteerNetworkReplayInputSchema = opensteerNetworkReplayInputSchema;
 exports.opensteerNetworkSummaryRecordSchema = opensteerNetworkSummaryRecordSchema;
 exports.opensteerNetworkTagInputSchema = opensteerNetworkTagInputSchema;
 exports.opensteerNetworkTagOutputSchema = opensteerNetworkTagOutputSchema;
-exports.opensteerObservationClusterRelationshipKindSchema = opensteerObservationClusterRelationshipKindSchema;
-exports.opensteerObservationClusterSchema = opensteerObservationClusterSchema;
 exports.opensteerOperationNames = opensteerOperationNames;
 exports.opensteerOperationSpecificationMap = opensteerOperationSpecificationMap;
 exports.opensteerOperationSpecifications = opensteerOperationSpecifications;
@@ -8022,12 +6067,6 @@ exports.opensteerProtocolDescriptor = opensteerProtocolDescriptor;
 exports.opensteerProtocolDescriptorSchema = opensteerProtocolDescriptorSchema;
 exports.opensteerRawRequestInputSchema = opensteerRawRequestInputSchema;
 exports.opensteerRawRequestOutputSchema = opensteerRawRequestOutputSchema;
-exports.opensteerRecipeCachePolicySchema = opensteerRecipeCachePolicySchema;
-exports.opensteerRecipeHookRefSchema = opensteerRecipeHookRefSchema;
-exports.opensteerRecipePayloadSchema = opensteerRecipePayloadSchema;
-exports.opensteerRecipeRecordSchema = opensteerRecipeRecordSchema;
-exports.opensteerRecipeRefSchema = opensteerRecipeRefSchema;
-exports.opensteerRecipeStepSchema = opensteerRecipeStepSchema;
 exports.opensteerRefKindSchema = opensteerRefKindSchema;
 exports.opensteerRefSchema = opensteerRefSchema;
 exports.opensteerRegistryProvenanceSchema = opensteerRegistryProvenanceSchema;
@@ -8037,13 +6076,6 @@ exports.opensteerRequestExecuteInputSchema = opensteerRequestExecuteInputSchema;
 exports.opensteerRequestExecuteOutputSchema = opensteerRequestExecuteOutputSchema;
 exports.opensteerRequestFailurePolicyHeaderMatchSchema = opensteerRequestFailurePolicyHeaderMatchSchema;
 exports.opensteerRequestFailurePolicySchema = opensteerRequestFailurePolicySchema;
-exports.opensteerRequestInputClassificationSchema = opensteerRequestInputClassificationSchema;
-exports.opensteerRequestInputDescriptorSchema = opensteerRequestInputDescriptorSchema;
-exports.opensteerRequestInputExportPolicySchema = opensteerRequestInputExportPolicySchema;
-exports.opensteerRequestInputLocationSchema = opensteerRequestInputLocationSchema;
-exports.opensteerRequestInputMaterializationPolicySchema = opensteerRequestInputMaterializationPolicySchema;
-exports.opensteerRequestInputRequirednessSchema = opensteerRequestInputRequirednessSchema;
-exports.opensteerRequestInputSourceSchema = opensteerRequestInputSourceSchema;
 exports.opensteerRequestPlanAuthSchema = opensteerRequestPlanAuthSchema;
 exports.opensteerRequestPlanBodySchema = opensteerRequestPlanBodySchema;
 exports.opensteerRequestPlanEndpointSchema = opensteerRequestPlanEndpointSchema;
@@ -8051,10 +6083,7 @@ exports.opensteerRequestPlanFreshnessSchema = opensteerRequestPlanFreshnessSchem
 exports.opensteerRequestPlanParameterLocationSchema = opensteerRequestPlanParameterLocationSchema;
 exports.opensteerRequestPlanParameterSchema = opensteerRequestPlanParameterSchema;
 exports.opensteerRequestPlanPayloadSchema = opensteerRequestPlanPayloadSchema;
-exports.opensteerRequestPlanRecipeBindingSchema = opensteerRequestPlanRecipeBindingSchema;
-exports.opensteerRequestPlanRecipesSchema = opensteerRequestPlanRecipesSchema;
 exports.opensteerRequestPlanRecordSchema = opensteerRequestPlanRecordSchema;
-exports.opensteerRequestPlanRecoverBindingSchema = opensteerRequestPlanRecoverBindingSchema;
 exports.opensteerRequestPlanResponseExpectationSchema = opensteerRequestPlanResponseExpectationSchema;
 exports.opensteerRequestPlanTransportSchema = opensteerRequestPlanTransportSchema;
 exports.opensteerRequestResponseResultSchema = opensteerRequestResponseResultSchema;
@@ -8063,68 +6092,6 @@ exports.opensteerRequestRetryPolicySchema = opensteerRequestRetryPolicySchema;
 exports.opensteerRequestScalarSchema = opensteerRequestScalarSchema;
 exports.opensteerRequestTransportResultSchema = opensteerRequestTransportResultSchema;
 exports.opensteerRestEndpoints = opensteerRestEndpoints;
-exports.opensteerReverseAdvisorySignalsSchema = opensteerReverseAdvisorySignalsSchema;
-exports.opensteerReverseAdvisoryTagSchema = opensteerReverseAdvisoryTagSchema;
-exports.opensteerReverseAdvisoryTemplateSchema = opensteerReverseAdvisoryTemplateSchema;
-exports.opensteerReverseCandidateBoundarySchema = opensteerReverseCandidateBoundarySchema;
-exports.opensteerReverseCandidateRecordSchema = opensteerReverseCandidateRecordSchema;
-exports.opensteerReverseCandidateReportItemSchema = opensteerReverseCandidateReportItemSchema;
-exports.opensteerReverseCasePayloadSchema = opensteerReverseCasePayloadSchema;
-exports.opensteerReverseCaseRecordSchema = opensteerReverseCaseRecordSchema;
-exports.opensteerReverseCaseStatusSchema = opensteerReverseCaseStatusSchema;
-exports.opensteerReverseChannelKindSchema = opensteerReverseChannelKindSchema;
-exports.opensteerReverseConstraintKindSchema = opensteerReverseConstraintKindSchema;
-exports.opensteerReverseDiscoverInputSchema = opensteerReverseDiscoverInputSchema;
-exports.opensteerReverseDiscoverOutputSchema = opensteerReverseDiscoverOutputSchema;
-exports.opensteerReverseExperimentRecordSchema = opensteerReverseExperimentRecordSchema;
-exports.opensteerReverseExportInputSchema = opensteerReverseExportInputSchema;
-exports.opensteerReverseExportOutputSchema = opensteerReverseExportOutputSchema;
-exports.opensteerReverseExportRecordSchema = opensteerReverseExportRecordSchema;
-exports.opensteerReverseGuardRecordSchema = opensteerReverseGuardRecordSchema;
-exports.opensteerReverseManualCalibrationModeSchema = opensteerReverseManualCalibrationModeSchema;
-exports.opensteerReverseObservationRecordSchema = opensteerReverseObservationRecordSchema;
-exports.opensteerReverseObservedRecordSchema = opensteerReverseObservedRecordSchema;
-exports.opensteerReversePackageCreateInputSchema = opensteerReversePackageCreateInputSchema;
-exports.opensteerReversePackageCreateOutputSchema = opensteerReversePackageCreateOutputSchema;
-exports.opensteerReversePackageGetInputSchema = opensteerReversePackageGetInputSchema;
-exports.opensteerReversePackageGetOutputSchema = opensteerReversePackageGetOutputSchema;
-exports.opensteerReversePackageKindSchema = opensteerReversePackageKindSchema;
-exports.opensteerReversePackageListInputSchema = opensteerReversePackageListInputSchema;
-exports.opensteerReversePackageListOutputSchema = opensteerReversePackageListOutputSchema;
-exports.opensteerReversePackagePatchInputSchema = opensteerReversePackagePatchInputSchema;
-exports.opensteerReversePackagePatchOutputSchema = opensteerReversePackagePatchOutputSchema;
-exports.opensteerReversePackagePayloadSchema = opensteerReversePackagePayloadSchema;
-exports.opensteerReversePackageReadinessSchema = opensteerReversePackageReadinessSchema;
-exports.opensteerReversePackageRecordSchema = opensteerReversePackageRecordSchema;
-exports.opensteerReversePackageRequirementsSchema = opensteerReversePackageRequirementsSchema;
-exports.opensteerReversePackageRunInputSchema = opensteerReversePackageRunInputSchema;
-exports.opensteerReversePackageRunOutputSchema = opensteerReversePackageRunOutputSchema;
-exports.opensteerReverseQueryInputSchema = opensteerReverseQueryInputSchema;
-exports.opensteerReverseQueryOutputSchema = opensteerReverseQueryOutputSchema;
-exports.opensteerReverseQueryViewSchema = opensteerReverseQueryViewSchema;
-exports.opensteerReverseReplayRunRecordSchema = opensteerReverseReplayRunRecordSchema;
-exports.opensteerReverseReplayValidationSchema = opensteerReverseReplayValidationSchema;
-exports.opensteerReverseReportInputSchema = opensteerReverseReportInputSchema;
-exports.opensteerReverseReportKindSchema = opensteerReverseReportKindSchema;
-exports.opensteerReverseReportOutputSchema = opensteerReverseReportOutputSchema;
-exports.opensteerReverseReportPayloadSchema = opensteerReverseReportPayloadSchema;
-exports.opensteerReverseReportRecordSchema = opensteerReverseReportRecordSchema;
-exports.opensteerReverseRequirementKindSchema = opensteerReverseRequirementKindSchema;
-exports.opensteerReverseRequirementSchema = opensteerReverseRequirementSchema;
-exports.opensteerReverseRequirementStatusSchema = opensteerReverseRequirementStatusSchema;
-exports.opensteerReverseSortDirectionSchema = opensteerReverseSortDirectionSchema;
-exports.opensteerReverseSortKeySchema = opensteerReverseSortKeySchema;
-exports.opensteerReverseSortPresetSchema = opensteerReverseSortPresetSchema;
-exports.opensteerReverseSuggestedEditKindSchema = opensteerReverseSuggestedEditKindSchema;
-exports.opensteerReverseSuggestedEditSchema = opensteerReverseSuggestedEditSchema;
-exports.opensteerReverseTargetHintsSchema = opensteerReverseTargetHintsSchema;
-exports.opensteerReverseWorkflowStepKindSchema = opensteerReverseWorkflowStepKindSchema;
-exports.opensteerReverseWorkflowStepSchema = opensteerReverseWorkflowStepSchema;
-exports.opensteerRunAuthRecipeInputSchema = opensteerRunAuthRecipeInputSchema;
-exports.opensteerRunAuthRecipeOutputSchema = opensteerRunAuthRecipeOutputSchema;
-exports.opensteerRunRecipeInputSchema = opensteerRunRecipeInputSchema;
-exports.opensteerRunRecipeOutputSchema = opensteerRunRecipeOutputSchema;
-exports.opensteerRuntimeValueKeySchema = opensteerRuntimeValueKeySchema;
 exports.opensteerScriptBeautifyInputSchema = opensteerScriptBeautifyInputSchema;
 exports.opensteerScriptBeautifyOutputSchema = opensteerScriptBeautifyOutputSchema;
 exports.opensteerScriptDeobfuscateInputSchema = opensteerScriptDeobfuscateInputSchema;
@@ -8141,16 +6108,8 @@ exports.opensteerStateDeltaSchema = opensteerStateDeltaSchema;
 exports.opensteerStateQueryInputSchema = opensteerStateQueryInputSchema;
 exports.opensteerStateQueryOutputSchema = opensteerStateQueryOutputSchema;
 exports.opensteerStateSnapshotSchema = opensteerStateSnapshotSchema;
-exports.opensteerStateSourceKindSchema = opensteerStateSourceKindSchema;
 exports.opensteerStorageQueryInputSchema = opensteerStorageQueryInputSchema;
 exports.opensteerStorageQueryOutputSchema = opensteerStorageQueryOutputSchema;
-exports.opensteerValidationRuleKindSchema = opensteerValidationRuleKindSchema;
-exports.opensteerValidationRuleSchema = opensteerValidationRuleSchema;
-exports.opensteerValueReferenceKindSchema = opensteerValueReferenceKindSchema;
-exports.opensteerValueReferenceSchema = opensteerValueReferenceSchema;
-exports.opensteerValueTemplateSchema = opensteerValueTemplateSchema;
-exports.opensteerWriteAuthRecipeInputSchema = opensteerWriteAuthRecipeInputSchema;
-exports.opensteerWriteRecipeInputSchema = opensteerWriteRecipeInputSchema;
 exports.opensteerWriteRequestPlanInputSchema = opensteerWriteRequestPlanInputSchema;
 exports.orderedHeadersSchema = orderedHeadersSchema;
 exports.pageInfoSchema = pageInfoSchema;