@makaio/framework 1.0.0-dev-1789056039016 → 1.0.0-dev-1789118938035

package/dist/{index-CKvliyuY.d.mts → index-C7XS5mvZ.d.mts}

@@ -1,4 +1,5 @@
-import { B as ArtifactCategory, C as ArtifactScope, G as ArtifactKindRegistration$1, Y as ArtifactLifecycleState, _ as ArtifactRelationTarget, p as ArtifactRelation, rt as ArtifactRef$1, s as ArtifactObservation$1, t as ArtifactActor, x as ArtifactRevision$1, y as ArtifactRepresentations } from "./schemas-_NrySTmN.mjs";
+import { C as ArtifactScope, K as ArtifactKindRegistration$1, V as ArtifactCategory, X as ArtifactLifecycleState, _ as ArtifactRelationTarget, it as ArtifactRef$1, p as ArtifactRelation, s as ArtifactObservation$1, t as ArtifactActor, x as ArtifactRevision$1, y as ArtifactRepresentations } from "./schemas-CXCdmM5K.mjs";
+import { l as JsonValue$1 } from "./json-value-DyMQrwGz.mjs";
 import { z } from "zod";
 import * as _$_makaio_core0 from "@makaio/framework/core";
 import { MakaioBusLike } from "@makaio/framework/core";
@@ -536,16 +537,51 @@ declare function defineArtifactKind<TData extends Record<string, unknown>, const
 //#region core/contracts/src/artifact/data-schema-validator.d.ts
 /** Validates one artifact payload against its registered JSON Schema. */
 type ArtifactDataValidator = (data: unknown) => boolean;
+/** One rejected location within an artifact payload, with what the schema expected there. */
+interface ArtifactDataIssue {
+  /** Dot-separated data-relative path of the rejected value; empty for the payload root. */
+  readonly path: string;
+  /** What the schema expected at that path. */
+  readonly reason: string;
+  /** Declared type at that path, when the rejection names one. */
+  readonly expectedType?: string;
+  /** Declared value set at that path, when the rejection names one. */
+  readonly allowedValues?: readonly JsonValue$1[];
+}
+/** Complete outcome of checking one artifact payload. */
+type ArtifactDataCheck = {
+  readonly valid: true;
+} | {
+  readonly valid: false;
+  readonly issues: readonly ArtifactDataIssue[];
+};
+/** Checks one artifact payload and reports every rejected location. */
+type ArtifactDataChecker = (data: unknown) => ArtifactDataCheck;
 /**
- * Compile the JSON Schema declared by one artifact kind.
+ * Compile a predicate for complete artifact payload validation.
  *
- * Each invocation creates an isolated compiler so local schema identifiers
- * cannot satisfy references belonging to another kind.
+ * The predicate hides the compiled function's mutable `errors`, so a caller
+ * cannot read error state left behind by an unrelated call. Use
+ * {@link compileArtifactDataChecker} when the rejections themselves are needed.
  * @param registration - Structurally validated artifact kind registration.
  * @returns A predicate for complete artifact payload validation.
  * @throws When the declared data schema cannot be compiled by its supported dialect.
  */
 declare function compileArtifactDataSchema(registration: ArtifactKindRegistration$1): ArtifactDataValidator;
+/**
+ * Compile a checker that reports why an artifact payload was rejected.
+ *
+ * Use this where the caller has to repair the payload rather than merely learn
+ * that it is invalid: each issue names a path and, where the schema declares
+ * one, the expected type or the allowed values.
+ *
+ * The returned checker owns its compiled function and reads that function's
+ * errors before returning, so concurrent callers each need their own checker.
+ * @param registration - Structurally validated artifact kind registration.
+ * @returns A checker producing one issue per rejected location.
+ * @throws When the declared data schema cannot be compiled by its supported dialect.
+ */
+declare function compileArtifactDataChecker(registration: ArtifactKindRegistration$1): ArtifactDataChecker;
 //#endregion
 //#region core/contracts/src/artifact/context-selectors.d.ts
 /** Known render hints for artifact context resolution. */
@@ -926,7 +962,7 @@ declare function hydrateArtifactContextTree(wire: ResolvedArtifactContextWire$1)
  *
  * - Shared lifecycle get / history / transition RPCs and committed / rejected events
  * - Kind and relation-type registration RPCs
- * - Revision create / revise / resolve / query / compare RPCs
+ * - Revision create / revise / patch / resolve / query / compare RPCs
  * - `created`, `revised`, `relation.added`, `observation.added`,
  *   `status.changed`, and `kind.changed` revision and registry events
  *
@@ -1664,6 +1700,111 @@ declare const ArtifactSchemas$1: {
         createdAt: z.ZodOptional<z.ZodNumber>;
       }, z.core.$strip>;
     }, z.core.$strip>;
+  };
+  /**
+   * Revise an existing artifact by patching the revision named by `baseRevision` (RPC).
+   *
+   * The request carries the change rather than the payload, so its cost follows
+   * the size of the change. Rejections are returned in band with the failing
+   * path and a repair hint; a stale `baseRevision` reports the current revision
+   * along with the repair the caller must follow — only an append at a fixed
+   * path can be resent without re-reading the payload.
+   */
+  patch: {
+    request: z.ZodObject<{
+      ref: z.ZodObject<{
+        kind: z.ZodString;
+        id: z.ZodString;
+      }, z.core.$strict>;
+      baseRevision: z.ZodString;
+      patch: z.ZodObject<{
+        $set: z.ZodOptional<z.ZodType<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>, z.core.$ZodTypeInternals<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>>>>;
+        $unset: z.ZodOptional<z.ZodType<Record<string, true>, Record<string, true>, z.core.$ZodTypeInternals<Record<string, true>, Record<string, true>>>>;
+        $push: z.ZodOptional<z.ZodType<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>, z.core.$ZodTypeInternals<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>>>>;
+        $pull: z.ZodOptional<z.ZodType<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>, z.core.$ZodTypeInternals<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>>>>;
+        arrayFilters: z.ZodOptional<z.ZodArray<z.ZodType<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>, z.core.$ZodTypeInternals<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>>>>>;
+      }, z.core.$strict>;
+      dryRun: z.ZodOptional<z.ZodBoolean>;
+      statusPath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    response: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+      ok: z.ZodLiteral<true>;
+      base: z.ZodObject<{
+        refClass: z.ZodLiteral<"artifact">;
+        kind: z.ZodString;
+        id: z.ZodString;
+        revision: z.ZodString;
+      }, z.core.$strict>;
+      operations: z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+          $set: "$set";
+          $unset: "$unset";
+          $push: "$push";
+          $pull: "$pull";
+        }>;
+        path: z.ZodString;
+        matched: z.ZodNumber;
+      }, z.core.$strict>>;
+      dryRun: z.ZodLiteral<true>;
+    }, z.core.$strict>, z.ZodObject<{
+      ok: z.ZodLiteral<true>;
+      base: z.ZodObject<{
+        refClass: z.ZodLiteral<"artifact">;
+        kind: z.ZodString;
+        id: z.ZodString;
+        revision: z.ZodString;
+      }, z.core.$strict>;
+      operations: z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+          $set: "$set";
+          $unset: "$unset";
+          $push: "$push";
+          $pull: "$pull";
+        }>;
+        path: z.ZodString;
+        matched: z.ZodNumber;
+      }, z.core.$strict>>;
+      dryRun: z.ZodLiteral<false>;
+      artifact: z.ZodObject<{
+        refClass: z.ZodLiteral<"artifact">;
+        kind: z.ZodString;
+        id: z.ZodString;
+        revision: z.ZodString;
+      }, z.core.$strict>;
+    }, z.core.$strict>], "dryRun">, z.ZodObject<{
+      ok: z.ZodLiteral<false>;
+      error: z.ZodObject<{
+        code: z.ZodEnum<{
+          ARTIFACT_NOT_FOUND: "ARTIFACT_NOT_FOUND";
+          BASE_REVISION_CONFLICT: "BASE_REVISION_CONFLICT";
+          KIND_NOT_REGISTERED: "KIND_NOT_REGISTERED";
+          SCHEMA_VERSION_MISMATCH: "SCHEMA_VERSION_MISMATCH";
+          PATH_NOT_DECLARED: "PATH_NOT_DECLARED";
+          PATH_NOT_RESOLVABLE: "PATH_NOT_RESOLVABLE";
+          TARGET_NOT_A_COLLECTION: "TARGET_NOT_A_COLLECTION";
+          UNSUPPORTED_TARGET: "UNSUPPORTED_TARGET";
+          NO_MATCH: "NO_MATCH";
+          SCHEMA_VALIDATION_FAILED: "SCHEMA_VALIDATION_FAILED";
+          HOST_FAILED: "HOST_FAILED";
+        }>;
+        message: z.ZodString;
+        operator: z.ZodOptional<z.ZodEnum<{
+          $set: "$set";
+          $unset: "$unset";
+          $push: "$push";
+          $pull: "$pull";
+        }>>;
+        path: z.ZodOptional<z.ZodString>;
+        currentRevision: z.ZodOptional<z.ZodString>;
+        issues: z.ZodOptional<z.ZodArray<z.ZodObject<{
+          path: z.ZodString;
+          reason: z.ZodString;
+          expectedType: z.ZodOptional<z.ZodString>;
+          allowedValues: z.ZodOptional<z.ZodArray<z.ZodType<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue, z.core.$ZodTypeInternals<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue>>>>;
+        }, z.core.$strict>>>;
+        repair: z.ZodString;
+      }, z.core.$strict>;
+    }, z.core.$strict>]>;
   }; /** Resolve a specific artifact revision by reference (RPC). */
   resolve: {
     request: z.ZodObject<{
@@ -4260,6 +4401,111 @@ declare const ArtifactNamespace: _$_makaio_core0.BusNamespaceDefinition<"artifac
         createdAt: z.ZodOptional<z.ZodNumber>;
       }, z.core.$strip>;
     }, z.core.$strip>;
+  };
+  /**
+   * Revise an existing artifact by patching the revision named by `baseRevision` (RPC).
+   *
+   * The request carries the change rather than the payload, so its cost follows
+   * the size of the change. Rejections are returned in band with the failing
+   * path and a repair hint; a stale `baseRevision` reports the current revision
+   * along with the repair the caller must follow — only an append at a fixed
+   * path can be resent without re-reading the payload.
+   */
+  patch: {
+    request: z.ZodObject<{
+      ref: z.ZodObject<{
+        kind: z.ZodString;
+        id: z.ZodString;
+      }, z.core.$strict>;
+      baseRevision: z.ZodString;
+      patch: z.ZodObject<{
+        $set: z.ZodOptional<z.ZodType<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>, z.core.$ZodTypeInternals<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>>>>;
+        $unset: z.ZodOptional<z.ZodType<Record<string, true>, Record<string, true>, z.core.$ZodTypeInternals<Record<string, true>, Record<string, true>>>>;
+        $push: z.ZodOptional<z.ZodType<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>, z.core.$ZodTypeInternals<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>>>>;
+        $pull: z.ZodOptional<z.ZodType<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>, z.core.$ZodTypeInternals<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>>>>;
+        arrayFilters: z.ZodOptional<z.ZodArray<z.ZodType<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>, z.core.$ZodTypeInternals<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>>>>>;
+      }, z.core.$strict>;
+      dryRun: z.ZodOptional<z.ZodBoolean>;
+      statusPath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    response: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+      ok: z.ZodLiteral<true>;
+      base: z.ZodObject<{
+        refClass: z.ZodLiteral<"artifact">;
+        kind: z.ZodString;
+        id: z.ZodString;
+        revision: z.ZodString;
+      }, z.core.$strict>;
+      operations: z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+          $set: "$set";
+          $unset: "$unset";
+          $push: "$push";
+          $pull: "$pull";
+        }>;
+        path: z.ZodString;
+        matched: z.ZodNumber;
+      }, z.core.$strict>>;
+      dryRun: z.ZodLiteral<true>;
+    }, z.core.$strict>, z.ZodObject<{
+      ok: z.ZodLiteral<true>;
+      base: z.ZodObject<{
+        refClass: z.ZodLiteral<"artifact">;
+        kind: z.ZodString;
+        id: z.ZodString;
+        revision: z.ZodString;
+      }, z.core.$strict>;
+      operations: z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+          $set: "$set";
+          $unset: "$unset";
+          $push: "$push";
+          $pull: "$pull";
+        }>;
+        path: z.ZodString;
+        matched: z.ZodNumber;
+      }, z.core.$strict>>;
+      dryRun: z.ZodLiteral<false>;
+      artifact: z.ZodObject<{
+        refClass: z.ZodLiteral<"artifact">;
+        kind: z.ZodString;
+        id: z.ZodString;
+        revision: z.ZodString;
+      }, z.core.$strict>;
+    }, z.core.$strict>], "dryRun">, z.ZodObject<{
+      ok: z.ZodLiteral<false>;
+      error: z.ZodObject<{
+        code: z.ZodEnum<{
+          ARTIFACT_NOT_FOUND: "ARTIFACT_NOT_FOUND";
+          BASE_REVISION_CONFLICT: "BASE_REVISION_CONFLICT";
+          KIND_NOT_REGISTERED: "KIND_NOT_REGISTERED";
+          SCHEMA_VERSION_MISMATCH: "SCHEMA_VERSION_MISMATCH";
+          PATH_NOT_DECLARED: "PATH_NOT_DECLARED";
+          PATH_NOT_RESOLVABLE: "PATH_NOT_RESOLVABLE";
+          TARGET_NOT_A_COLLECTION: "TARGET_NOT_A_COLLECTION";
+          UNSUPPORTED_TARGET: "UNSUPPORTED_TARGET";
+          NO_MATCH: "NO_MATCH";
+          SCHEMA_VALIDATION_FAILED: "SCHEMA_VALIDATION_FAILED";
+          HOST_FAILED: "HOST_FAILED";
+        }>;
+        message: z.ZodString;
+        operator: z.ZodOptional<z.ZodEnum<{
+          $set: "$set";
+          $unset: "$unset";
+          $push: "$push";
+          $pull: "$pull";
+        }>>;
+        path: z.ZodOptional<z.ZodString>;
+        currentRevision: z.ZodOptional<z.ZodString>;
+        issues: z.ZodOptional<z.ZodArray<z.ZodObject<{
+          path: z.ZodString;
+          reason: z.ZodString;
+          expectedType: z.ZodOptional<z.ZodString>;
+          allowedValues: z.ZodOptional<z.ZodArray<z.ZodType<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue, z.core.$ZodTypeInternals<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue>>>>;
+        }, z.core.$strict>>>;
+        repair: z.ZodString;
+      }, z.core.$strict>;
+    }, z.core.$strict>]>;
   }; /** Resolve a specific artifact revision by reference (RPC). */
   resolve: {
     request: z.ZodObject<{
@@ -6134,6 +6380,7 @@ declare const ArtifactNamespace: _$_makaio_core0.BusNamespaceDefinition<"artifac
  * - `ArtifactSubjects.lifecycle.rejected` — supplemental rejected transition event
  * - `ArtifactSubjects.create` — create artifact (RPC)
  * - `ArtifactSubjects.revise` — revise artifact (RPC)
+ * - `ArtifactSubjects.patch` — revise artifact by patch (RPC)
  * - `ArtifactSubjects.resolve` — resolve artifact by ref (RPC)
  * - `ArtifactSubjects.query` — query artifacts (RPC)
  * - `ArtifactSubjects.compare` — compare two revisions (RPC)
@@ -6876,6 +7123,111 @@ declare const ArtifactSubjects$1: _$_makaio_core0.BusSubjects<_$_makaio_core0.Fl
         createdAt: z.ZodOptional<z.ZodNumber>;
       }, z.core.$strip>;
     }, z.core.$strip>;
+  };
+  /**
+   * Revise an existing artifact by patching the revision named by `baseRevision` (RPC).
+   *
+   * The request carries the change rather than the payload, so its cost follows
+   * the size of the change. Rejections are returned in band with the failing
+   * path and a repair hint; a stale `baseRevision` reports the current revision
+   * along with the repair the caller must follow — only an append at a fixed
+   * path can be resent without re-reading the payload.
+   */
+  patch: {
+    request: z.ZodObject<{
+      ref: z.ZodObject<{
+        kind: z.ZodString;
+        id: z.ZodString;
+      }, z.core.$strict>;
+      baseRevision: z.ZodString;
+      patch: z.ZodObject<{
+        $set: z.ZodOptional<z.ZodType<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>, z.core.$ZodTypeInternals<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>>>>;
+        $unset: z.ZodOptional<z.ZodType<Record<string, true>, Record<string, true>, z.core.$ZodTypeInternals<Record<string, true>, Record<string, true>>>>;
+        $push: z.ZodOptional<z.ZodType<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>, z.core.$ZodTypeInternals<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>>>>;
+        $pull: z.ZodOptional<z.ZodType<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>, z.core.$ZodTypeInternals<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>>>>;
+        arrayFilters: z.ZodOptional<z.ZodArray<z.ZodType<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>, z.core.$ZodTypeInternals<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>>>>>;
+      }, z.core.$strict>;
+      dryRun: z.ZodOptional<z.ZodBoolean>;
+      statusPath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    response: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+      ok: z.ZodLiteral<true>;
+      base: z.ZodObject<{
+        refClass: z.ZodLiteral<"artifact">;
+        kind: z.ZodString;
+        id: z.ZodString;
+        revision: z.ZodString;
+      }, z.core.$strict>;
+      operations: z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+          $set: "$set";
+          $unset: "$unset";
+          $push: "$push";
+          $pull: "$pull";
+        }>;
+        path: z.ZodString;
+        matched: z.ZodNumber;
+      }, z.core.$strict>>;
+      dryRun: z.ZodLiteral<true>;
+    }, z.core.$strict>, z.ZodObject<{
+      ok: z.ZodLiteral<true>;
+      base: z.ZodObject<{
+        refClass: z.ZodLiteral<"artifact">;
+        kind: z.ZodString;
+        id: z.ZodString;
+        revision: z.ZodString;
+      }, z.core.$strict>;
+      operations: z.ZodArray<z.ZodObject<{
+        operator: z.ZodEnum<{
+          $set: "$set";
+          $unset: "$unset";
+          $push: "$push";
+          $pull: "$pull";
+        }>;
+        path: z.ZodString;
+        matched: z.ZodNumber;
+      }, z.core.$strict>>;
+      dryRun: z.ZodLiteral<false>;
+      artifact: z.ZodObject<{
+        refClass: z.ZodLiteral<"artifact">;
+        kind: z.ZodString;
+        id: z.ZodString;
+        revision: z.ZodString;
+      }, z.core.$strict>;
+    }, z.core.$strict>], "dryRun">, z.ZodObject<{
+      ok: z.ZodLiteral<false>;
+      error: z.ZodObject<{
+        code: z.ZodEnum<{
+          ARTIFACT_NOT_FOUND: "ARTIFACT_NOT_FOUND";
+          BASE_REVISION_CONFLICT: "BASE_REVISION_CONFLICT";
+          KIND_NOT_REGISTERED: "KIND_NOT_REGISTERED";
+          SCHEMA_VERSION_MISMATCH: "SCHEMA_VERSION_MISMATCH";
+          PATH_NOT_DECLARED: "PATH_NOT_DECLARED";
+          PATH_NOT_RESOLVABLE: "PATH_NOT_RESOLVABLE";
+          TARGET_NOT_A_COLLECTION: "TARGET_NOT_A_COLLECTION";
+          UNSUPPORTED_TARGET: "UNSUPPORTED_TARGET";
+          NO_MATCH: "NO_MATCH";
+          SCHEMA_VALIDATION_FAILED: "SCHEMA_VALIDATION_FAILED";
+          HOST_FAILED: "HOST_FAILED";
+        }>;
+        message: z.ZodString;
+        operator: z.ZodOptional<z.ZodEnum<{
+          $set: "$set";
+          $unset: "$unset";
+          $push: "$push";
+          $pull: "$pull";
+        }>>;
+        path: z.ZodOptional<z.ZodString>;
+        currentRevision: z.ZodOptional<z.ZodString>;
+        issues: z.ZodOptional<z.ZodArray<z.ZodObject<{
+          path: z.ZodString;
+          reason: z.ZodString;
+          expectedType: z.ZodOptional<z.ZodString>;
+          allowedValues: z.ZodOptional<z.ZodArray<z.ZodType<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue, z.core.$ZodTypeInternals<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue>>>>;
+        }, z.core.$strict>>>;
+        repair: z.ZodString;
+      }, z.core.$strict>;
+    }, z.core.$strict>]>;
   }; /** Resolve a specific artifact revision by reference (RPC). */
   resolve: {
     request: z.ZodObject<{
@@ -8759,6 +9111,10 @@ type ArtifactCreateResponse = z.infer<(typeof ArtifactSchemas$1)['create']['resp
 type ArtifactReviseRequest = z.infer<(typeof ArtifactSchemas$1)['revise']['request']>;
 /** Response payload for creating a new artifact revision. */
 type ArtifactReviseResponse = z.infer<(typeof ArtifactSchemas$1)['revise']['response']>;
+/** Request payload for revising an artifact by patch. */
+type ArtifactPatchSubjectRequest = z.infer<(typeof ArtifactSchemas$1)['patch']['request']>;
+/** Response payload for revising an artifact by patch. */
+type ArtifactPatchSubjectResponse = z.infer<(typeof ArtifactSchemas$1)['patch']['response']>;
 /** Request payload for resolving an artifact by reference. */
 type ArtifactResolveRequest = z.infer<(typeof ArtifactSchemas$1)['resolve']['request']>;
 /** Response payload for resolving an artifact by reference. */
@@ -8787,12 +9143,39 @@ type ArtifactStatusChangedPayload = z.infer<(typeof ArtifactSchemas$1)['status.c
 type ArtifactKindChangedPayload = z.infer<(typeof ArtifactSchemas$1)['kind.changed']>;
 //#endregion
 //#region core/contracts/src/artifact/kind-paths.d.ts
+/** One schema declaration reachable at an inspected location. */
+type ArtifactSchemaFragment = boolean | Record<string, unknown>;
+/**
+ * Location segment selecting one element of a declared array.
+ *
+ * Named-property paths cannot express it, so callers that address list entries
+ * — a write addressing one collection entry, for instance — substitute this
+ * token for the concrete position or match that selects the element. Schema
+ * inspection is identical for either, because both resolve to the array's
+ * declared item schema.
+ *
+ * The brackets are what make the token unambiguous: {@link ArtifactDataPathSchema}
+ * admits no bracket in a property name, so no real property can be mistaken for
+ * an element selector when a dotted path is split into segments.
+ */
+declare const ARTIFACT_COLLECTION_ELEMENT_SEGMENT = "[]";
+/**
+ * Inspect the serialized schema fragments selected by one data-relative location.
+ *
+ * Segments name object properties, or select one element of a declared array
+ * through {@link ARTIFACT_COLLECTION_ELEMENT_SEGMENT}. Multiple fragments
+ * represent the location's coverage across all schema variants.
+ * @param dataSchema - Serialized artifact data schema.
+ * @param segments - Data-relative location segments.
+ * @returns Covered schema fragments, or undefined when the location is not declared in every variant.
+ */
+declare function inspectArtifactDataLocation(dataSchema: Record<string, unknown>, segments: readonly string[]): readonly ArtifactSchemaFragment[] | undefined;
 /**
  * Determine whether a data-relative path is declared in every schema variant.
  *
  * Paths traverse named object properties only. A terminal array is valid and
- * represents the complete original array; selecting its elements is outside
- * this contract.
+ * represents the complete original array; selecting its elements uses
+ * {@link inspectArtifactDataLocation} with {@link ARTIFACT_COLLECTION_ELEMENT_SEGMENT}.
  * @param dataSchema - Serialized artifact data schema.
  * @param path - Data-relative object-property path.
  * @returns Whether the path is declared in every schema variant.
@@ -8806,6 +9189,457 @@ declare function isArtifactDataPathDeclared(dataSchema: Record<string, unknown>,
  */
 declare function readArtifactTitle(data: Record<string, unknown>, titlePath: string): string;
 //#endregion
+//#region core/contracts/src/artifact/patch.d.ts
+/**
+ * Update operators this contract declares.
+ *
+ * The set is a deliberately narrow subset of Mongo update semantics. It is
+ * closed: an operator outside this list is rejected by the request schema
+ * rather than ignored, so a caller never believes an unsupported instruction
+ * was carried out.
+ */
+declare const ARTIFACT_PATCH_OPERATORS: readonly ["$set", "$unset", "$push", "$pull"];
+/** One declared update operator. */
+type ArtifactPatchOperator = (typeof ARTIFACT_PATCH_OPERATORS)[number];
+/**
+ * A dot-separated location inside artifact `data`.
+ *
+ * The first segment is always an object property of `data`. Later segments are
+ * an object property, a canonical array position (`tasks.3.title`), or an array
+ * filter placeholder (`tasks.$[entry].title`) bound by `arrayFilters`. Filter
+ * addressing is what keeps a write independent of the list order a caller read
+ * earlier, so a concurrent insertion does not silently move the target.
+ */
+declare const ArtifactPatchPathSchema: z.ZodString;
+/** What one segment of a patch path addresses. */
+type ArtifactPatchSegment = {
+  readonly kind: 'property';
+  readonly name: string;
+} | {
+  readonly kind: 'index';
+  readonly index: number;
+} | {
+  readonly kind: 'filter';
+  readonly placeholder: string;
+};
+/**
+ * Classify one segment of a patch path.
+ *
+ * The grammar lives here alongside the pattern that admits it, so a caller
+ * walking a path can never disagree with the schema that accepted it.
+ * @param segment - One segment of a path already accepted by {@link ArtifactPatchPathSchema}.
+ * @returns What the segment addresses.
+ */
+declare function artifactPatchSegment(segment: string): ArtifactPatchSegment;
+/**
+ * Split a patch path into its classified segments.
+ * @param path - Path already accepted by {@link ArtifactPatchPathSchema}.
+ * @returns One classified segment per path element, in order.
+ */
+declare function artifactPatchSegments(path: string): ArtifactPatchSegment[];
+/**
+ * List the array filter placeholders a patch path refers to.
+ * @param path - Path already accepted by {@link ArtifactPatchPathSchema}.
+ * @returns Placeholder names in order of appearance, with duplicates retained.
+ */
+declare function artifactPatchPathFilterNames(path: string): string[];
+/**
+ * One `arrayFilters` entry, restricted to equality on the matched element.
+ *
+ * Every key starts with the placeholder name this entry binds. The bare name
+ * compares the whole element; `name.field.path` compares one property of it.
+ * Comparison operators are outside the declared subset.
+ */
+declare const ArtifactPatchArrayFilterSchema: z.ZodType<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>, z.core.$ZodTypeInternals<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>>>;
+/**
+ * Read the placeholder name an array filter binds.
+ * @param filter - One array filter entry.
+ * @returns The single bound placeholder name, or undefined when the entry binds none or several.
+ */
+declare function artifactPatchFilterName(filter: Record<string, unknown>): string | undefined;
+/** One instruction of a patch document: an operator, where it applies, and its operand. */
+interface ArtifactPatchInstruction {
+  /** Operator to apply. */
+  readonly operator: ArtifactPatchOperator;
+  /** Path the operator applies to. */
+  readonly path: string;
+  /** Value or condition the caller wrote for this path. */
+  readonly value: unknown;
+}
+/**
+ * List every instruction of a patch document in application order.
+ *
+ * Operators run in the order {@link ARTIFACT_PATCH_OPERATORS} declares and,
+ * within one operator, in the order the caller wrote its paths, so the same
+ * document always produces the same result.
+ *
+ * The parameter is spelled structurally rather than as the document type,
+ * because the document's own schema calls this while refining itself.
+ * @param patch - Structurally valid patch operations.
+ * @returns Operator, path and operand for each declared instruction.
+ */
+declare function artifactPatchInstructions(patch: Readonly<Partial<Record<ArtifactPatchOperator, Readonly<Record<string, unknown>>>>>): ArtifactPatchInstruction[];
+/**
+ * A complete patch document.
+ *
+ * Cross-field rules — at least one instruction, and placeholders matching their
+ * filters exactly — are refinements. A JSON Schema rendering of this subject
+ * therefore describes the operator set and the path grammar but not those
+ * rules, exactly as for the other refined artifact contracts; the server
+ * rejects a document that only the refinements catch.
+ */
+declare const ArtifactPatchDocumentSchema: z.ZodObject<{
+  $set: z.ZodOptional<z.ZodType<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>, z.core.$ZodTypeInternals<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>>>>;
+  $unset: z.ZodOptional<z.ZodType<Record<string, true>, Record<string, true>, z.core.$ZodTypeInternals<Record<string, true>, Record<string, true>>>>;
+  $push: z.ZodOptional<z.ZodType<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>, z.core.$ZodTypeInternals<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>>>>;
+  $pull: z.ZodOptional<z.ZodType<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>, z.core.$ZodTypeInternals<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>>>>;
+  arrayFilters: z.ZodOptional<z.ZodArray<z.ZodType<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>, z.core.$ZodTypeInternals<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>>>>>;
+}, z.core.$strict>;
+/** Identity of the artifact being revised; the revision travels as `baseRevision`. */
+declare const ArtifactPatchTargetSchema: z.ZodObject<{
+  kind: z.ZodString;
+  id: z.ZodString;
+}, z.core.$strict>;
+/**
+ * Request one patch-based artifact revision.
+ *
+ * `baseRevision` is mandatory: the write applies to that exact revision or is
+ * rejected, so a caller never overwrites a concurrent revision it never saw.
+ * `statusPath` is the same caller-owned observation metadata a full `revise`
+ * carries, so patching an artifact does not silently lose the status change a
+ * host would otherwise emit.
+ */
+declare const ArtifactPatchRequestSchema: z.ZodObject<{
+  ref: z.ZodObject<{
+    kind: z.ZodString;
+    id: z.ZodString;
+  }, z.core.$strict>;
+  baseRevision: z.ZodString;
+  patch: z.ZodObject<{
+    $set: z.ZodOptional<z.ZodType<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>, z.core.$ZodTypeInternals<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>>>>;
+    $unset: z.ZodOptional<z.ZodType<Record<string, true>, Record<string, true>, z.core.$ZodTypeInternals<Record<string, true>, Record<string, true>>>>;
+    $push: z.ZodOptional<z.ZodType<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>, z.core.$ZodTypeInternals<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>>>>;
+    $pull: z.ZodOptional<z.ZodType<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>, z.core.$ZodTypeInternals<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>>>>;
+    arrayFilters: z.ZodOptional<z.ZodArray<z.ZodType<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>, z.core.$ZodTypeInternals<Record<string, _$_makaio_contracts0.JsonValue>, Record<string, _$_makaio_contracts0.JsonValue>>>>>;
+  }, z.core.$strict>;
+  dryRun: z.ZodOptional<z.ZodBoolean>;
+  statusPath: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/** Stable failure classifications for a patch request. */
+declare const ARTIFACT_PATCH_ERROR_CODES: readonly ["ARTIFACT_NOT_FOUND", "BASE_REVISION_CONFLICT", "KIND_NOT_REGISTERED", "SCHEMA_VERSION_MISMATCH", "PATH_NOT_DECLARED", "PATH_NOT_RESOLVABLE", "TARGET_NOT_A_COLLECTION", "UNSUPPORTED_TARGET", "NO_MATCH", "SCHEMA_VALIDATION_FAILED", "HOST_FAILED"];
+/** One reason the patched result was rejected, addressed within `data`. */
+declare const ArtifactPatchIssueSchema: z.ZodObject<{
+  path: z.ZodString;
+  reason: z.ZodString;
+  expectedType: z.ZodOptional<z.ZodString>;
+  allowedValues: z.ZodOptional<z.ZodArray<z.ZodType<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue, z.core.$ZodTypeInternals<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue>>>>;
+}, z.core.$strict>;
+/**
+ * A rejected patch request.
+ *
+ * Every rejection names the failing location and carries a repair hint, so a
+ * caller learns the next step from the rejection itself. The hint is what
+ * distinguishes a correctable request from an outcome that is unknown, so it is
+ * required rather than optional.
+ *
+ * A `BASE_REVISION_CONFLICT` additionally names the revision the artifact
+ * carries: recovery from a conflict is rebasing onto that revision, so a
+ * conflict without it would be unactionable. The schema enforces the pairing
+ * rather than trusting each producer to remember it.
+ */
+declare const ArtifactPatchErrorSchema: z.ZodObject<{
+  code: z.ZodEnum<{
+    ARTIFACT_NOT_FOUND: "ARTIFACT_NOT_FOUND";
+    BASE_REVISION_CONFLICT: "BASE_REVISION_CONFLICT";
+    KIND_NOT_REGISTERED: "KIND_NOT_REGISTERED";
+    SCHEMA_VERSION_MISMATCH: "SCHEMA_VERSION_MISMATCH";
+    PATH_NOT_DECLARED: "PATH_NOT_DECLARED";
+    PATH_NOT_RESOLVABLE: "PATH_NOT_RESOLVABLE";
+    TARGET_NOT_A_COLLECTION: "TARGET_NOT_A_COLLECTION";
+    UNSUPPORTED_TARGET: "UNSUPPORTED_TARGET";
+    NO_MATCH: "NO_MATCH";
+    SCHEMA_VALIDATION_FAILED: "SCHEMA_VALIDATION_FAILED";
+    HOST_FAILED: "HOST_FAILED";
+  }>;
+  message: z.ZodString;
+  operator: z.ZodOptional<z.ZodEnum<{
+    $set: "$set";
+    $unset: "$unset";
+    $push: "$push";
+    $pull: "$pull";
+  }>>;
+  path: z.ZodOptional<z.ZodString>;
+  currentRevision: z.ZodOptional<z.ZodString>;
+  issues: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    path: z.ZodString;
+    reason: z.ZodString;
+    expectedType: z.ZodOptional<z.ZodString>;
+    allowedValues: z.ZodOptional<z.ZodArray<z.ZodType<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue, z.core.$ZodTypeInternals<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue>>>>;
+  }, z.core.$strict>>>;
+  repair: z.ZodString;
+}, z.core.$strict>;
+/** What one applied instruction did. */
+declare const ArtifactPatchOperationResultSchema: z.ZodObject<{
+  operator: z.ZodEnum<{
+    $set: "$set";
+    $unset: "$unset";
+    $push: "$push";
+    $pull: "$pull";
+  }>;
+  path: z.ZodString;
+  matched: z.ZodNumber;
+}, z.core.$strict>;
+/** A patch that was applied, validated and discarded without producing history. */
+declare const ArtifactPatchDryRunSchema: z.ZodObject<{
+  ok: z.ZodLiteral<true>;
+  base: z.ZodObject<{
+    refClass: z.ZodLiteral<"artifact">;
+    kind: z.ZodString;
+    id: z.ZodString;
+    revision: z.ZodString;
+  }, z.core.$strict>;
+  operations: z.ZodArray<z.ZodObject<{
+    operator: z.ZodEnum<{
+      $set: "$set";
+      $unset: "$unset";
+      $push: "$push";
+      $pull: "$pull";
+    }>;
+    path: z.ZodString;
+    matched: z.ZodNumber;
+  }, z.core.$strict>>;
+  dryRun: z.ZodLiteral<true>;
+}, z.core.$strict>;
+/** A patch that was applied, validated and persisted as a new revision. */
+declare const ArtifactPatchPersistedSchema: z.ZodObject<{
+  ok: z.ZodLiteral<true>;
+  base: z.ZodObject<{
+    refClass: z.ZodLiteral<"artifact">;
+    kind: z.ZodString;
+    id: z.ZodString;
+    revision: z.ZodString;
+  }, z.core.$strict>;
+  operations: z.ZodArray<z.ZodObject<{
+    operator: z.ZodEnum<{
+      $set: "$set";
+      $unset: "$unset";
+      $push: "$push";
+      $pull: "$pull";
+    }>;
+    path: z.ZodString;
+    matched: z.ZodNumber;
+  }, z.core.$strict>>;
+  dryRun: z.ZodLiteral<false>;
+  artifact: z.ZodObject<{
+    refClass: z.ZodLiteral<"artifact">;
+    kind: z.ZodString;
+    id: z.ZodString;
+    revision: z.ZodString;
+  }, z.core.$strict>;
+}, z.core.$strict>;
+/**
+ * An applied patch.
+ *
+ * The two variants keep `dryRun` and the new reference in step: a persisted
+ * result always names its revision, and a dry run can never appear to have
+ * produced one.
+ */
+declare const ArtifactPatchSuccessSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  ok: z.ZodLiteral<true>;
+  base: z.ZodObject<{
+    refClass: z.ZodLiteral<"artifact">;
+    kind: z.ZodString;
+    id: z.ZodString;
+    revision: z.ZodString;
+  }, z.core.$strict>;
+  operations: z.ZodArray<z.ZodObject<{
+    operator: z.ZodEnum<{
+      $set: "$set";
+      $unset: "$unset";
+      $push: "$push";
+      $pull: "$pull";
+    }>;
+    path: z.ZodString;
+    matched: z.ZodNumber;
+  }, z.core.$strict>>;
+  dryRun: z.ZodLiteral<true>;
+}, z.core.$strict>, z.ZodObject<{
+  ok: z.ZodLiteral<true>;
+  base: z.ZodObject<{
+    refClass: z.ZodLiteral<"artifact">;
+    kind: z.ZodString;
+    id: z.ZodString;
+    revision: z.ZodString;
+  }, z.core.$strict>;
+  operations: z.ZodArray<z.ZodObject<{
+    operator: z.ZodEnum<{
+      $set: "$set";
+      $unset: "$unset";
+      $push: "$push";
+      $pull: "$pull";
+    }>;
+    path: z.ZodString;
+    matched: z.ZodNumber;
+  }, z.core.$strict>>;
+  dryRun: z.ZodLiteral<false>;
+  artifact: z.ZodObject<{
+    refClass: z.ZodLiteral<"artifact">;
+    kind: z.ZodString;
+    id: z.ZodString;
+    revision: z.ZodString;
+  }, z.core.$strict>;
+}, z.core.$strict>], "dryRun">;
+/**
+ * A rejected patch.
+ *
+ * A rejection by the engine — an undeclared path, an unmatched filter, a result
+ * the kind schema refuses — and a `BASE_REVISION_CONFLICT`, whether the stale
+ * base revision was caught before the write or the store refused it, all
+ * guarantee that nothing was persisted. `HOST_FAILED` does not: a host that
+ * failed while persisting may have committed the write before the failure
+ * surfaced, so the outcome is unknown and the caller must re-read before
+ * retrying. The error's `repair` says which case this is.
+ */
+declare const ArtifactPatchFailureSchema: z.ZodObject<{
+  ok: z.ZodLiteral<false>;
+  error: z.ZodObject<{
+    code: z.ZodEnum<{
+      ARTIFACT_NOT_FOUND: "ARTIFACT_NOT_FOUND";
+      BASE_REVISION_CONFLICT: "BASE_REVISION_CONFLICT";
+      KIND_NOT_REGISTERED: "KIND_NOT_REGISTERED";
+      SCHEMA_VERSION_MISMATCH: "SCHEMA_VERSION_MISMATCH";
+      PATH_NOT_DECLARED: "PATH_NOT_DECLARED";
+      PATH_NOT_RESOLVABLE: "PATH_NOT_RESOLVABLE";
+      TARGET_NOT_A_COLLECTION: "TARGET_NOT_A_COLLECTION";
+      UNSUPPORTED_TARGET: "UNSUPPORTED_TARGET";
+      NO_MATCH: "NO_MATCH";
+      SCHEMA_VALIDATION_FAILED: "SCHEMA_VALIDATION_FAILED";
+      HOST_FAILED: "HOST_FAILED";
+    }>;
+    message: z.ZodString;
+    operator: z.ZodOptional<z.ZodEnum<{
+      $set: "$set";
+      $unset: "$unset";
+      $push: "$push";
+      $pull: "$pull";
+    }>>;
+    path: z.ZodOptional<z.ZodString>;
+    currentRevision: z.ZodOptional<z.ZodString>;
+    issues: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      path: z.ZodString;
+      reason: z.ZodString;
+      expectedType: z.ZodOptional<z.ZodString>;
+      allowedValues: z.ZodOptional<z.ZodArray<z.ZodType<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue, z.core.$ZodTypeInternals<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue>>>>;
+    }, z.core.$strict>>>;
+    repair: z.ZodString;
+  }, z.core.$strict>;
+}, z.core.$strict>;
+/**
+ * Outcome of a patch request.
+ *
+ * Rejections are in-band results rather than transport errors: they are the
+ * expected way an agent learns which path to correct, and they must survive the
+ * MCP facade unchanged.
+ */
+declare const ArtifactPatchResponseSchema: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+  ok: z.ZodLiteral<true>;
+  base: z.ZodObject<{
+    refClass: z.ZodLiteral<"artifact">;
+    kind: z.ZodString;
+    id: z.ZodString;
+    revision: z.ZodString;
+  }, z.core.$strict>;
+  operations: z.ZodArray<z.ZodObject<{
+    operator: z.ZodEnum<{
+      $set: "$set";
+      $unset: "$unset";
+      $push: "$push";
+      $pull: "$pull";
+    }>;
+    path: z.ZodString;
+    matched: z.ZodNumber;
+  }, z.core.$strict>>;
+  dryRun: z.ZodLiteral<true>;
+}, z.core.$strict>, z.ZodObject<{
+  ok: z.ZodLiteral<true>;
+  base: z.ZodObject<{
+    refClass: z.ZodLiteral<"artifact">;
+    kind: z.ZodString;
+    id: z.ZodString;
+    revision: z.ZodString;
+  }, z.core.$strict>;
+  operations: z.ZodArray<z.ZodObject<{
+    operator: z.ZodEnum<{
+      $set: "$set";
+      $unset: "$unset";
+      $push: "$push";
+      $pull: "$pull";
+    }>;
+    path: z.ZodString;
+    matched: z.ZodNumber;
+  }, z.core.$strict>>;
+  dryRun: z.ZodLiteral<false>;
+  artifact: z.ZodObject<{
+    refClass: z.ZodLiteral<"artifact">;
+    kind: z.ZodString;
+    id: z.ZodString;
+    revision: z.ZodString;
+  }, z.core.$strict>;
+}, z.core.$strict>], "dryRun">, z.ZodObject<{
+  ok: z.ZodLiteral<false>;
+  error: z.ZodObject<{
+    code: z.ZodEnum<{
+      ARTIFACT_NOT_FOUND: "ARTIFACT_NOT_FOUND";
+      BASE_REVISION_CONFLICT: "BASE_REVISION_CONFLICT";
+      KIND_NOT_REGISTERED: "KIND_NOT_REGISTERED";
+      SCHEMA_VERSION_MISMATCH: "SCHEMA_VERSION_MISMATCH";
+      PATH_NOT_DECLARED: "PATH_NOT_DECLARED";
+      PATH_NOT_RESOLVABLE: "PATH_NOT_RESOLVABLE";
+      TARGET_NOT_A_COLLECTION: "TARGET_NOT_A_COLLECTION";
+      UNSUPPORTED_TARGET: "UNSUPPORTED_TARGET";
+      NO_MATCH: "NO_MATCH";
+      SCHEMA_VALIDATION_FAILED: "SCHEMA_VALIDATION_FAILED";
+      HOST_FAILED: "HOST_FAILED";
+    }>;
+    message: z.ZodString;
+    operator: z.ZodOptional<z.ZodEnum<{
+      $set: "$set";
+      $unset: "$unset";
+      $push: "$push";
+      $pull: "$pull";
+    }>>;
+    path: z.ZodOptional<z.ZodString>;
+    currentRevision: z.ZodOptional<z.ZodString>;
+    issues: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      path: z.ZodString;
+      reason: z.ZodString;
+      expectedType: z.ZodOptional<z.ZodString>;
+      allowedValues: z.ZodOptional<z.ZodArray<z.ZodType<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue, z.core.$ZodTypeInternals<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue>>>>;
+    }, z.core.$strict>>>;
+    repair: z.ZodString;
+  }, z.core.$strict>;
+}, z.core.$strict>]>;
+/** One array filter entry restricted to equality matching. */
+type ArtifactPatchArrayFilter = z.infer<typeof ArtifactPatchArrayFilterSchema>;
+/** A complete patch document. */
+type ArtifactPatchDocument = z.infer<typeof ArtifactPatchDocumentSchema>;
+/** Artifact identity addressed by a patch request. */
+type ArtifactPatchTarget = z.infer<typeof ArtifactPatchTargetSchema>;
+/** Request payload for one patch-based artifact revision. */
+type ArtifactPatchRequest = z.infer<typeof ArtifactPatchRequestSchema>;
+/** Stable failure classification for a patch request. */
+type ArtifactPatchErrorCode = (typeof ARTIFACT_PATCH_ERROR_CODES)[number];
+/** One schema rejection of a patched result. */
+type ArtifactPatchIssue = z.infer<typeof ArtifactPatchIssueSchema>;
+/** A rejected patch request. */
+type ArtifactPatchError = z.infer<typeof ArtifactPatchErrorSchema>;
+/** What one applied instruction did. */
+type ArtifactPatchOperationResult = z.infer<typeof ArtifactPatchOperationResultSchema>;
+/** An applied patch outcome. */
+type ArtifactPatchSuccess = z.infer<typeof ArtifactPatchSuccessSchema>;
+/** Outcome of a patch request. */
+type ArtifactPatchResponse = z.infer<typeof ArtifactPatchResponseSchema>;
+//#endregion
 //#region core/contracts/src/artifact/lifecycle.d.ts
 /**
  * An artifact identity independent of its immutable content revisions. The `refClass`
@@ -10468,4 +11302,4 @@ type ArtifactLifecycleFailure = z.infer<typeof ArtifactLifecycleFailureSchema>;
 /** Supplemental reaction input following a rejected valid transition request. */
 type ArtifactLifecycleRejectedPayload = z.infer<typeof ArtifactLifecycleRejectedPayloadSchema>;
 //#endregion
-export { ArtifactKindListResponse as $, ArtifactLifecycleHookEvent as $t, ArtifactLifecycleSituation as A, ResolvedArtifactContextWire$1 as At, ArtifactLifecycleVersionSchema as B, ArtifactDataValidator as Bt, ArtifactLifecycleHistoryEntry as C, ArtifactContextTree as Ct, ArtifactLifecycleInitializedEntrySchema as D, ArtifactContextRefEntrySchema as Dt, ArtifactLifecycleInitializedEntry as E, ArtifactContextRefEntry as Et, ArtifactLifecycleTransitionCommandSchema as F, ArtifactContextRelationSelectorSchema as Ft, readArtifactTitle as G, ArtifactOf as Gt, initialArtifactLifecycle as H, AnyArtifactKindDefinition as Ht, ArtifactLifecycleTransitionIntent as I, ArtifactContextRenderHint as It, ArtifactCreatedPayload as J, AfterArtifactHookRegistration as Jt, ArtifactCreateRequest as K, defineArtifactKind as Kt, ArtifactLifecycleTransitionIntentSchema as L, ArtifactContextRenderHintSchema as Lt, ArtifactLifecycleSnapshot as M, ARTIFACT_CONTEXT_RENDER_HINTS as Mt, ArtifactLifecycleSnapshotSchema as N, ArtifactContextKnownRenderHint as Nt, ArtifactLifecycleRejection as O, ArtifactContextUnresolvedReason as Ot, ArtifactLifecycleTransitionCommand as P, ArtifactContextRelationSelector as Pt, ArtifactKindListRequest as Q, ArtifactLifecycleHookDefinition as Qt, ArtifactLifecycleTransitionedEntry as R, ArtifactContextSelector$1 as Rt, ArtifactLifecycleError as S, ArtifactContextRootNode as St, ArtifactLifecycleIdentitySchema as T, UnresolvedArtifactContextNode as Tt, isArtifactLifecycleTransitionAllowed as U, ArtifactDataOf as Ut, advanceArtifactLifecycle as V, compileArtifactDataSchema as Vt, isArtifactDataPathDeclared as W, ArtifactKindDefinition as Wt, ArtifactEvidenceResolveResponse$1 as X, ArtifactDraftPatch as Xt, ArtifactEvidenceResolveRequest as Y, ArtifactDraft as Yt, ArtifactKindChangedPayload as Z, ArtifactHookFilter as Zt, ArtifactLifecycleTransitionResponseSchema as _, ArtifactSchemas$1 as _t, ArtifactLifecycleGetRequest as a, EvidenceOccurrence as an, ArtifactRelationAddedPayload as at, ArtifactLifecycleCurrent as b, hydrateArtifactContextTree as bt, ArtifactLifecycleGetResponseSchema as c, EvidenceResolveRequest as cn, ArtifactRelationTypeRegisterRequest as ct, ArtifactLifecycleHistoryResponse as d, EvidenceResolveResponseSchema as dn, ArtifactResolveContextResponse as dt, ArtifactLifecycleHookRegistration$1 as en, ArtifactKindRegisterRequest as et, ArtifactLifecycleHistoryResponseSchema as f, ARTIFACT_VALUE_TYPE_KEYWORD as fn, ArtifactResolveRequest as ft, ArtifactLifecycleTransitionResponse as g, ArtifactRevisedPayload as gt, ArtifactLifecycleSchemas as h, EvidenceValueSchema$1 as hn, ArtifactReviseResponse as ht, ArtifactLifecycleFailureSchema as i, defineArtifactLifecycleHooks as in, ArtifactQueryResponse as it, ArtifactLifecycleSituationSchema as j, ResolvedArtifactContextWireSchema as jt, ArtifactLifecycleRejectionSchema as k, ArtifactContextUnresolvedReasonSchema as kt, ArtifactLifecycleHistoryRequest as l, EvidenceResolveRequestSchema as ln, ArtifactRelationTypeRegisterResponse as lt, ArtifactLifecycleRejectedPayloadSchema as m, EvidenceValue$1 as mn, ArtifactReviseRequest as mt, ArtifactLifecycleCommittedPayloadSchema as n, BeforeArtifactHookContext as nn, ArtifactNamespace as nt, ArtifactLifecycleGetRequestSchema as o, EvidenceOccurrenceExtractionOptions as on, ArtifactRelationTypeListRequest as ot, ArtifactLifecycleRejectedPayload as p, EVIDENCE_VALUE_TYPE as pn, ArtifactResolveResponse as pt, ArtifactCreateResponse as q, AfterArtifactHookContext as qt, ArtifactLifecycleFailure as r, BeforeArtifactHookRegistration as rn, ArtifactObservationAddedPayload as rt, ArtifactLifecycleGetResponse as s, extractEvidenceOccurrences as sn, ArtifactRelationTypeListResponse as st, ArtifactLifecycleCommittedPayload as t, ArtifactLifecycleSemanticEvent as tn, ArtifactKindRegisterResponse as tt, ArtifactLifecycleHistoryRequestSchema as u, EvidenceResolveResponse as un, ArtifactResolveContextRequest as ut, toArtifactLifecycleFailure as v, ArtifactStatusChangedPayload as vt, ArtifactLifecycleHistoryEntrySchema as w, ResolvedArtifactContextNode as wt, ArtifactLifecycleCurrentSchema as x, ArtifactContextNode as xt, ARTIFACT_LIFECYCLE_REJECTED_CODE as y, ArtifactSubjects$1 as yt, ArtifactLifecycleTransitionedEntrySchema as z, ArtifactContextSelectorSchema as zt };
+export { ArtifactPatchErrorSchema as $, EvidenceResolveResponseSchema as $n, ArtifactReviseResponse as $t, ArtifactLifecycleSituation as A, AnyArtifactKindDefinition as An, ArtifactCreatedPayload as At, ArtifactLifecycleVersionSchema as B, ArtifactLifecycleHookDefinition as Bn, ArtifactPatchSubjectRequest as Bt, ArtifactLifecycleHistoryEntry as C, ArtifactContextSelectorSchema as Cn, ARTIFACT_COLLECTION_ELEMENT_SEGMENT as Ct, ArtifactLifecycleInitializedEntrySchema as D, ArtifactDataValidator as Dn, readArtifactTitle as Dt, ArtifactLifecycleInitializedEntry as E, ArtifactDataIssue as En, isArtifactDataPathDeclared as Et, ArtifactLifecycleTransitionCommandSchema as F, AfterArtifactHookContext as Fn, ArtifactKindListResponse as Ft, ARTIFACT_PATCH_OPERATORS as G, BeforeArtifactHookRegistration as Gn, ArtifactRelationTypeListResponse as Gt, initialArtifactLifecycle as H, ArtifactLifecycleHookRegistration$1 as Hn, ArtifactQueryResponse as Ht, ArtifactLifecycleTransitionIntent as I, AfterArtifactHookRegistration as In, ArtifactKindRegisterRequest as It, ArtifactPatchDocument as J, EvidenceOccurrenceExtractionOptions as Jn, ArtifactResolveContextRequest as Jt, ArtifactPatchArrayFilter as K, defineArtifactLifecycleHooks as Kn, ArtifactRelationTypeRegisterRequest as Kt, ArtifactLifecycleTransitionIntentSchema as L, ArtifactDraft as Ln, ArtifactKindRegisterResponse as Lt, ArtifactLifecycleSnapshot as M, ArtifactKindDefinition as Mn, ArtifactEvidenceResolveResponse$1 as Mt, ArtifactLifecycleSnapshotSchema as N, ArtifactOf as Nn, ArtifactKindChangedPayload as Nt, ArtifactLifecycleRejection as O, compileArtifactDataChecker as On, ArtifactCreateRequest as Ot, ArtifactLifecycleTransitionCommand as P, defineArtifactKind as Pn, ArtifactKindListRequest as Pt, ArtifactPatchErrorCode as Q, EvidenceResolveResponse as Qn, ArtifactReviseRequest as Qt, ArtifactLifecycleTransitionedEntry as R, ArtifactDraftPatch as Rn, ArtifactNamespace as Rt, ArtifactLifecycleError as S, ArtifactContextSelector$1 as Sn, artifactPatchSegments as St, ArtifactLifecycleIdentitySchema as T, ArtifactDataChecker as Tn, inspectArtifactDataLocation as Tt, isArtifactLifecycleTransitionAllowed as U, ArtifactLifecycleSemanticEvent as Un, ArtifactRelationAddedPayload as Ut, advanceArtifactLifecycle as V, ArtifactLifecycleHookEvent as Vn, ArtifactPatchSubjectResponse as Vt, ARTIFACT_PATCH_ERROR_CODES as W, BeforeArtifactHookContext as Wn, ArtifactRelationTypeListRequest as Wt, ArtifactPatchDryRunSchema as X, EvidenceResolveRequest as Xn, ArtifactResolveRequest as Xt, ArtifactPatchDocumentSchema as Y, extractEvidenceOccurrences as Yn, ArtifactResolveContextResponse as Yt, ArtifactPatchError as Z, EvidenceResolveRequestSchema as Zn, ArtifactResolveResponse as Zt, ArtifactLifecycleTransitionResponseSchema as _, ArtifactContextKnownRenderHint as _n, ArtifactPatchTargetSchema as _t, ArtifactLifecycleGetRequest as a, ArtifactContextNode as an, ArtifactPatchOperationResultSchema as at, ArtifactLifecycleCurrent as b, ArtifactContextRenderHint as bn, artifactPatchPathFilterNames as bt, ArtifactLifecycleGetResponseSchema as c, ResolvedArtifactContextNode as cn, ArtifactPatchPersistedSchema as ct, ArtifactLifecycleHistoryResponse as d, ArtifactContextRefEntrySchema as dn, ArtifactPatchResponse as dt, ArtifactRevisedPayload as en, ARTIFACT_VALUE_TYPE_KEYWORD as er, ArtifactPatchFailureSchema as et, ArtifactLifecycleHistoryResponseSchema as f, ArtifactContextUnresolvedReason as fn, ArtifactPatchResponseSchema as ft, ArtifactLifecycleTransitionResponse as g, ARTIFACT_CONTEXT_RENDER_HINTS as gn, ArtifactPatchTarget as gt, ArtifactLifecycleSchemas as h, ResolvedArtifactContextWireSchema as hn, ArtifactPatchSuccessSchema as ht, ArtifactLifecycleFailureSchema as i, hydrateArtifactContextTree as in, ArtifactPatchOperationResult as it, ArtifactLifecycleSituationSchema as j, ArtifactDataOf as jn, ArtifactEvidenceResolveRequest as jt, ArtifactLifecycleRejectionSchema as k, compileArtifactDataSchema as kn, ArtifactCreateResponse as kt, ArtifactLifecycleHistoryRequest as l, UnresolvedArtifactContextNode as ln, ArtifactPatchRequest as lt, ArtifactLifecycleRejectedPayloadSchema as m, ResolvedArtifactContextWire$1 as mn, ArtifactPatchSuccess as mt, ArtifactLifecycleCommittedPayloadSchema as n, ArtifactStatusChangedPayload as nn, EvidenceValue$1 as nr, ArtifactPatchIssue as nt, ArtifactLifecycleGetRequestSchema as o, ArtifactContextRootNode as on, ArtifactPatchOperator as ot, ArtifactLifecycleRejectedPayload as p, ArtifactContextUnresolvedReasonSchema as pn, ArtifactPatchSegment as pt, ArtifactPatchArrayFilterSchema as q, EvidenceOccurrence as qn, ArtifactRelationTypeRegisterResponse as qt, ArtifactLifecycleFailure as r, ArtifactSubjects$1 as rn, EvidenceValueSchema$1 as rr, ArtifactPatchIssueSchema as rt, ArtifactLifecycleGetResponse as s, ArtifactContextTree as sn, ArtifactPatchPathSchema as st, ArtifactLifecycleCommittedPayload as t, ArtifactSchemas$1 as tn, EVIDENCE_VALUE_TYPE as tr, ArtifactPatchInstruction as tt, ArtifactLifecycleHistoryRequestSchema as u, ArtifactContextRefEntry as un, ArtifactPatchRequestSchema as ut, toArtifactLifecycleFailure as v, ArtifactContextRelationSelector as vn, artifactPatchFilterName as vt, ArtifactLifecycleHistoryEntrySchema as w, ArtifactDataCheck as wn, ArtifactSchemaFragment as wt, ArtifactLifecycleCurrentSchema as x, ArtifactContextRenderHintSchema as xn, artifactPatchSegment as xt, ARTIFACT_LIFECYCLE_REJECTED_CODE as y, ArtifactContextRelationSelectorSchema as yn, artifactPatchInstructions as yt, ArtifactLifecycleTransitionedEntrySchema as z, ArtifactHookFilter as zn, ArtifactObservationAddedPayload as zt };