@makaio/framework 1.0.0-dev-1789056466138 → 1.0.0-dev-1789138982585

package/dist/{index-C1PsT7hg.d.mts → index-BGg5g9cK.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
  *
@@ -1137,6 +1173,16 @@ declare const ArtifactSchemas$1: {
         excerpt: z.ZodOptional<z.ZodString>;
       }, z.core.$strict>]>>>;
       createdAt: z.ZodOptional<z.ZodNumber>;
+      schemaVersion: z.ZodNumber;
+      scope: z.ZodObject<{
+        level: z.ZodString;
+        ids: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+      }, z.core.$strip>;
+      actor: z.ZodObject<{
+        kind: z.ZodString;
+        id: z.ZodString;
+        displayName: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>;
       relations: z.ZodArray<z.ZodObject<{
         type: z.ZodString;
         target: z.ZodPreprocess<z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -1165,16 +1211,6 @@ declare const ArtifactSchemas$1: {
           id: z.ZodString;
         }, z.core.$strict>], "refClass">>;
       }, z.core.$strip>>;
-      schemaVersion: z.ZodNumber;
-      scope: z.ZodObject<{
-        level: z.ZodString;
-        ids: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-      }, z.core.$strip>;
-      actor: z.ZodObject<{
-        kind: z.ZodString;
-        id: z.ZodString;
-        displayName: z.ZodOptional<z.ZodString>;
-      }, z.core.$strip>;
       confidence: z.ZodOptional<z.ZodObject<{
         level: z.ZodEnum<{
           inferred: "inferred";
@@ -1431,6 +1467,16 @@ declare const ArtifactSchemas$1: {
           excerpt: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>]>>>;
         createdAt: z.ZodOptional<z.ZodNumber>;
+        schemaVersion: z.ZodNumber;
+        scope: z.ZodObject<{
+          level: z.ZodString;
+          ids: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>;
+        actor: z.ZodObject<{
+          kind: z.ZodString;
+          id: z.ZodString;
+          displayName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
         relations: z.ZodArray<z.ZodObject<{
           type: z.ZodString;
           target: z.ZodPreprocess<z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -1459,16 +1505,6 @@ declare const ArtifactSchemas$1: {
             id: z.ZodString;
           }, z.core.$strict>], "refClass">>;
         }, z.core.$strip>>;
-        schemaVersion: z.ZodNumber;
-        scope: z.ZodObject<{
-          level: z.ZodString;
-          ids: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-        }, z.core.$strip>;
-        actor: z.ZodObject<{
-          kind: z.ZodString;
-          id: z.ZodString;
-          displayName: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>;
         confidence: z.ZodOptional<z.ZodObject<{
           level: z.ZodEnum<{
             inferred: "inferred";
@@ -1664,6 +1700,126 @@ 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>;
+      schemaVersion: z.ZodOptional<z.ZodNumber>;
+      statusPath: z.ZodOptional<z.ZodString>;
+      representations: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        markdown: z.ZodOptional<z.ZodString>;
+        summary: z.ZodOptional<z.ZodString>;
+        plaintext: z.ZodOptional<z.ZodString>;
+      }, z.core.$strict>>>;
+    }, 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>>;
+      migration: z.ZodOptional<z.ZodObject<{
+        from: z.ZodNumber;
+        to: 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>>;
+      migration: z.ZodOptional<z.ZodObject<{
+        from: z.ZodNumber;
+        to: 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";
+          NO_CHANGE: "NO_CHANGE";
+          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<{
@@ -3733,6 +3889,16 @@ declare const ArtifactNamespace: _$_makaio_core0.BusNamespaceDefinition<"artifac
         excerpt: z.ZodOptional<z.ZodString>;
       }, z.core.$strict>]>>>;
       createdAt: z.ZodOptional<z.ZodNumber>;
+      schemaVersion: z.ZodNumber;
+      scope: z.ZodObject<{
+        level: z.ZodString;
+        ids: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+      }, z.core.$strip>;
+      actor: z.ZodObject<{
+        kind: z.ZodString;
+        id: z.ZodString;
+        displayName: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>;
       relations: z.ZodArray<z.ZodObject<{
         type: z.ZodString;
         target: z.ZodPreprocess<z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -3761,16 +3927,6 @@ declare const ArtifactNamespace: _$_makaio_core0.BusNamespaceDefinition<"artifac
           id: z.ZodString;
         }, z.core.$strict>], "refClass">>;
       }, z.core.$strip>>;
-      schemaVersion: z.ZodNumber;
-      scope: z.ZodObject<{
-        level: z.ZodString;
-        ids: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-      }, z.core.$strip>;
-      actor: z.ZodObject<{
-        kind: z.ZodString;
-        id: z.ZodString;
-        displayName: z.ZodOptional<z.ZodString>;
-      }, z.core.$strip>;
       confidence: z.ZodOptional<z.ZodObject<{
         level: z.ZodEnum<{
           inferred: "inferred";
@@ -4027,6 +4183,16 @@ declare const ArtifactNamespace: _$_makaio_core0.BusNamespaceDefinition<"artifac
           excerpt: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>]>>>;
         createdAt: z.ZodOptional<z.ZodNumber>;
+        schemaVersion: z.ZodNumber;
+        scope: z.ZodObject<{
+          level: z.ZodString;
+          ids: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>;
+        actor: z.ZodObject<{
+          kind: z.ZodString;
+          id: z.ZodString;
+          displayName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
         relations: z.ZodArray<z.ZodObject<{
           type: z.ZodString;
           target: z.ZodPreprocess<z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -4055,16 +4221,6 @@ declare const ArtifactNamespace: _$_makaio_core0.BusNamespaceDefinition<"artifac
             id: z.ZodString;
           }, z.core.$strict>], "refClass">>;
         }, z.core.$strip>>;
-        schemaVersion: z.ZodNumber;
-        scope: z.ZodObject<{
-          level: z.ZodString;
-          ids: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-        }, z.core.$strip>;
-        actor: z.ZodObject<{
-          kind: z.ZodString;
-          id: z.ZodString;
-          displayName: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>;
         confidence: z.ZodOptional<z.ZodObject<{
           level: z.ZodEnum<{
             inferred: "inferred";
@@ -4260,6 +4416,126 @@ 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>;
+      schemaVersion: z.ZodOptional<z.ZodNumber>;
+      statusPath: z.ZodOptional<z.ZodString>;
+      representations: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        markdown: z.ZodOptional<z.ZodString>;
+        summary: z.ZodOptional<z.ZodString>;
+        plaintext: z.ZodOptional<z.ZodString>;
+      }, z.core.$strict>>>;
+    }, 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>>;
+      migration: z.ZodOptional<z.ZodObject<{
+        from: z.ZodNumber;
+        to: 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>>;
+      migration: z.ZodOptional<z.ZodObject<{
+        from: z.ZodNumber;
+        to: 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";
+          NO_CHANGE: "NO_CHANGE";
+          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 +6410,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)
@@ -6349,6 +6626,16 @@ declare const ArtifactSubjects$1: _$_makaio_core0.BusSubjects<_$_makaio_core0.Fl
         excerpt: z.ZodOptional<z.ZodString>;
       }, z.core.$strict>]>>>;
       createdAt: z.ZodOptional<z.ZodNumber>;
+      schemaVersion: z.ZodNumber;
+      scope: z.ZodObject<{
+        level: z.ZodString;
+        ids: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+      }, z.core.$strip>;
+      actor: z.ZodObject<{
+        kind: z.ZodString;
+        id: z.ZodString;
+        displayName: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>;
       relations: z.ZodArray<z.ZodObject<{
         type: z.ZodString;
         target: z.ZodPreprocess<z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -6377,16 +6664,6 @@ declare const ArtifactSubjects$1: _$_makaio_core0.BusSubjects<_$_makaio_core0.Fl
           id: z.ZodString;
         }, z.core.$strict>], "refClass">>;
       }, z.core.$strip>>;
-      schemaVersion: z.ZodNumber;
-      scope: z.ZodObject<{
-        level: z.ZodString;
-        ids: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-      }, z.core.$strip>;
-      actor: z.ZodObject<{
-        kind: z.ZodString;
-        id: z.ZodString;
-        displayName: z.ZodOptional<z.ZodString>;
-      }, z.core.$strip>;
       confidence: z.ZodOptional<z.ZodObject<{
         level: z.ZodEnum<{
           inferred: "inferred";
@@ -6643,6 +6920,16 @@ declare const ArtifactSubjects$1: _$_makaio_core0.BusSubjects<_$_makaio_core0.Fl
           excerpt: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>]>>>;
         createdAt: z.ZodOptional<z.ZodNumber>;
+        schemaVersion: z.ZodNumber;
+        scope: z.ZodObject<{
+          level: z.ZodString;
+          ids: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>;
+        actor: z.ZodObject<{
+          kind: z.ZodString;
+          id: z.ZodString;
+          displayName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
         relations: z.ZodArray<z.ZodObject<{
           type: z.ZodString;
           target: z.ZodPreprocess<z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -6671,16 +6958,6 @@ declare const ArtifactSubjects$1: _$_makaio_core0.BusSubjects<_$_makaio_core0.Fl
             id: z.ZodString;
           }, z.core.$strict>], "refClass">>;
         }, z.core.$strip>>;
-        schemaVersion: z.ZodNumber;
-        scope: z.ZodObject<{
-          level: z.ZodString;
-          ids: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-        }, z.core.$strip>;
-        actor: z.ZodObject<{
-          kind: z.ZodString;
-          id: z.ZodString;
-          displayName: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>;
         confidence: z.ZodOptional<z.ZodObject<{
           level: z.ZodEnum<{
             inferred: "inferred";
@@ -6876,6 +7153,126 @@ 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>;
+      schemaVersion: z.ZodOptional<z.ZodNumber>;
+      statusPath: z.ZodOptional<z.ZodString>;
+      representations: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        markdown: z.ZodOptional<z.ZodString>;
+        summary: z.ZodOptional<z.ZodString>;
+        plaintext: z.ZodOptional<z.ZodString>;
+      }, z.core.$strict>>>;
+    }, 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>>;
+      migration: z.ZodOptional<z.ZodObject<{
+        from: z.ZodNumber;
+        to: 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>>;
+      migration: z.ZodOptional<z.ZodObject<{
+        from: z.ZodNumber;
+        to: 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";
+          NO_CHANGE: "NO_CHANGE";
+          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 +9156,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 +9188,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 +9234,507 @@ 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. `schemaVersion` names the registration the
+ * patched result is validated against and stored at; it defaults to the base
+ * revision's, so a patch never changes an artifact's schema version unless the
+ * caller asks for the migration.
+ */
+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>;
+  schemaVersion: z.ZodOptional<z.ZodNumber>;
+  statusPath: z.ZodOptional<z.ZodString>;
+  representations: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+    markdown: z.ZodOptional<z.ZodString>;
+    summary: z.ZodOptional<z.ZodString>;
+    plaintext: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>>;
+}, 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", "NO_CHANGE", "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";
+    NO_CHANGE: "NO_CHANGE";
+    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>;
+/**
+ * The schema versions a migrating patch moved the artifact between.
+ *
+ * The marker moves forward by construction, as every migration does: equal
+ * versions would describe no transition and let an instructionless ordinary
+ * success pass for a migration, and a lower target is a downgrade the tool
+ * never performs.
+ */
+declare const ArtifactPatchMigrationSchema: z.ZodObject<{
+  from: z.ZodNumber;
+  to: 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>>;
+  migration: z.ZodOptional<z.ZodObject<{
+    from: z.ZodNumber;
+    to: 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>>;
+  migration: z.ZodOptional<z.ZodObject<{
+    from: z.ZodNumber;
+    to: 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>>;
+  migration: z.ZodOptional<z.ZodObject<{
+    from: z.ZodNumber;
+    to: 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>>;
+  migration: z.ZodOptional<z.ZodObject<{
+    from: z.ZodNumber;
+    to: 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";
+      NO_CHANGE: "NO_CHANGE";
+      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>>;
+  migration: z.ZodOptional<z.ZodObject<{
+    from: z.ZodNumber;
+    to: 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>>;
+  migration: z.ZodOptional<z.ZodObject<{
+    from: z.ZodNumber;
+    to: 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";
+      NO_CHANGE: "NO_CHANGE";
+      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>;
+/** The schema versions a migrating patch moved the artifact between. */
+type ArtifactPatchMigration = z.infer<typeof ArtifactPatchMigrationSchema>;
+/** 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 +11397,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 $, EvidenceResolveRequestSchema as $n, ArtifactResolveResponse as $t, ArtifactLifecycleSituation as A, compileArtifactDataChecker as An, ArtifactCreateRequest as At, ArtifactLifecycleVersionSchema as B, ArtifactDraftPatch as Bn, ArtifactNamespace as Bt, ArtifactLifecycleHistoryEntry as C, ArtifactContextRenderHintSchema as Cn, artifactPatchSegment as Ct, ArtifactLifecycleInitializedEntrySchema as D, ArtifactDataChecker as Dn, inspectArtifactDataLocation as Dt, ArtifactLifecycleInitializedEntry as E, ArtifactDataCheck as En, ArtifactSchemaFragment as Et, ArtifactLifecycleTransitionCommandSchema as F, ArtifactOf as Fn, ArtifactKindChangedPayload as Ft, ARTIFACT_PATCH_OPERATORS as G, ArtifactLifecycleSemanticEvent as Gn, ArtifactRelationAddedPayload as Gt, initialArtifactLifecycle as H, ArtifactLifecycleHookDefinition as Hn, ArtifactPatchSubjectRequest as Ht, ArtifactLifecycleTransitionIntent as I, defineArtifactKind as In, ArtifactKindListRequest as It, ArtifactPatchDocument as J, defineArtifactLifecycleHooks as Jn, ArtifactRelationTypeRegisterRequest as Jt, ArtifactPatchArrayFilter as K, BeforeArtifactHookContext as Kn, ArtifactRelationTypeListRequest as Kt, ArtifactLifecycleTransitionIntentSchema as L, AfterArtifactHookContext as Ln, ArtifactKindListResponse as Lt, ArtifactLifecycleSnapshot as M, AnyArtifactKindDefinition as Mn, ArtifactCreatedPayload as Mt, ArtifactLifecycleSnapshotSchema as N, ArtifactDataOf as Nn, ArtifactEvidenceResolveRequest as Nt, ArtifactLifecycleRejection as O, ArtifactDataIssue as On, isArtifactDataPathDeclared as Ot, ArtifactLifecycleTransitionCommand as P, ArtifactKindDefinition as Pn, ArtifactEvidenceResolveResponse$1 as Pt, ArtifactPatchErrorCode as Q, EvidenceResolveRequest as Qn, ArtifactResolveRequest as Qt, ArtifactLifecycleTransitionedEntry as R, AfterArtifactHookRegistration as Rn, ArtifactKindRegisterRequest as Rt, ArtifactLifecycleError as S, ArtifactContextRenderHint as Sn, artifactPatchPathFilterNames as St, ArtifactLifecycleIdentitySchema as T, ArtifactContextSelectorSchema as Tn, ARTIFACT_COLLECTION_ELEMENT_SEGMENT as Tt, isArtifactLifecycleTransitionAllowed as U, ArtifactLifecycleHookEvent as Un, ArtifactPatchSubjectResponse as Ut, advanceArtifactLifecycle as V, ArtifactHookFilter as Vn, ArtifactObservationAddedPayload as Vt, ARTIFACT_PATCH_ERROR_CODES as W, ArtifactLifecycleHookRegistration$1 as Wn, ArtifactQueryResponse as Wt, ArtifactPatchDryRunSchema as X, EvidenceOccurrenceExtractionOptions as Xn, ArtifactResolveContextRequest as Xt, ArtifactPatchDocumentSchema as Y, EvidenceOccurrence as Yn, ArtifactRelationTypeRegisterResponse as Yt, ArtifactPatchError as Z, extractEvidenceOccurrences as Zn, ArtifactResolveContextResponse as Zt, ArtifactLifecycleTransitionResponseSchema as _, ResolvedArtifactContextWireSchema as _n, ArtifactPatchSuccessSchema as _t, ArtifactLifecycleGetRequest as a, ArtifactSubjects$1 as an, EvidenceValueSchema$1 as ar, ArtifactPatchMigrationSchema as at, ArtifactLifecycleCurrent as b, ArtifactContextRelationSelector as bn, artifactPatchFilterName as bt, ArtifactLifecycleGetResponseSchema as c, ArtifactContextRootNode as cn, ArtifactPatchOperator as ct, ArtifactLifecycleHistoryResponse as d, UnresolvedArtifactContextNode as dn, ArtifactPatchRequest as dt, ArtifactReviseRequest as en, EvidenceResolveResponse as er, ArtifactPatchFailureSchema as et, ArtifactLifecycleHistoryResponseSchema as f, ArtifactContextRefEntry as fn, ArtifactPatchRequestSchema as ft, ArtifactLifecycleTransitionResponse as g, ResolvedArtifactContextWire$1 as gn, ArtifactPatchSuccess as gt, ArtifactLifecycleSchemas as h, ArtifactContextUnresolvedReasonSchema as hn, ArtifactPatchSegment as ht, ArtifactLifecycleFailureSchema as i, ArtifactStatusChangedPayload as in, EvidenceValue$1 as ir, ArtifactPatchMigration as it, ArtifactLifecycleSituationSchema as j, compileArtifactDataSchema as jn, ArtifactCreateResponse as jt, ArtifactLifecycleRejectionSchema as k, ArtifactDataValidator as kn, readArtifactTitle as kt, ArtifactLifecycleHistoryRequest as l, ArtifactContextTree as ln, ArtifactPatchPathSchema as lt, ArtifactLifecycleRejectedPayloadSchema as m, ArtifactContextUnresolvedReason as mn, ArtifactPatchResponseSchema as mt, ArtifactLifecycleCommittedPayloadSchema as n, ArtifactRevisedPayload as nn, ARTIFACT_VALUE_TYPE_KEYWORD as nr, ArtifactPatchIssue as nt, ArtifactLifecycleGetRequestSchema as o, hydrateArtifactContextTree as on, ArtifactPatchOperationResult as ot, ArtifactLifecycleRejectedPayload as p, ArtifactContextRefEntrySchema as pn, ArtifactPatchResponse as pt, ArtifactPatchArrayFilterSchema as q, BeforeArtifactHookRegistration as qn, ArtifactRelationTypeListResponse as qt, ArtifactLifecycleFailure as r, ArtifactSchemas$1 as rn, EVIDENCE_VALUE_TYPE as rr, ArtifactPatchIssueSchema as rt, ArtifactLifecycleGetResponse as s, ArtifactContextNode as sn, ArtifactPatchOperationResultSchema as st, ArtifactLifecycleCommittedPayload as t, ArtifactReviseResponse as tn, EvidenceResolveResponseSchema as tr, ArtifactPatchInstruction as tt, ArtifactLifecycleHistoryRequestSchema as u, ResolvedArtifactContextNode as un, ArtifactPatchPersistedSchema as ut, toArtifactLifecycleFailure as v, ARTIFACT_CONTEXT_RENDER_HINTS as vn, ArtifactPatchTarget as vt, ArtifactLifecycleHistoryEntrySchema as w, ArtifactContextSelector$1 as wn, artifactPatchSegments as wt, ArtifactLifecycleCurrentSchema as x, ArtifactContextRelationSelectorSchema as xn, artifactPatchInstructions as xt, ARTIFACT_LIFECYCLE_REJECTED_CODE as y, ArtifactContextKnownRenderHint as yn, ArtifactPatchTargetSchema as yt, ArtifactLifecycleTransitionedEntrySchema as z, ArtifactDraft as zn, ArtifactKindRegisterResponse as zt };