@absolutejs/artifacts 0.0.1 → 0.0.3

package/dist/index.js

@@ -4,6 +4,18 @@ import { Value } from "@sinclair/typebox/value";
 
 // src/types.ts
 var ARTIFACT_STATUSES = ["draft", "published", "archived"];
+var ARTIFACT_EVENT_TYPES = [
+  "artifact.archived",
+  "artifact.asset_attached",
+  "artifact.asset_detached",
+  "artifact.created",
+  "artifact.generated",
+  "artifact.indexing_changed",
+  "artifact.published",
+  "artifact.restored",
+  "artifact.revised",
+  "artifact.unpublished"
+];
 
 class ArtifactError extends Error {
   code;
@@ -31,6 +43,108 @@ var defineArtifactRegistry = (definitions) => ({
     return content;
   }
 });
+// src/generators.ts
+var createArtifactGeneratorRegistry = (initial = []) => {
+  const generators = new Map(initial.map((generator) => [generator.kind, generator]));
+  return {
+    generate: async (service, input) => {
+      const generator = generators.get(input.kind);
+      if (!generator) {
+        throw new ArtifactError("generator_unavailable", `No generator is registered for ${input.kind} artifacts`);
+      }
+      const result = await generator.generate(input, {
+        ownerId: input.ownerId
+      });
+      const artifact = await service.createBundle(input.ownerId, {
+        assets: result.assets,
+        content: result.content,
+        createdBy: input.createdBy,
+        kind: input.kind,
+        metadata: {
+          ...result.metadata,
+          ...result.warnings?.length ? { generationWarnings: result.warnings } : {}
+        },
+        provenance: result.provenance,
+        title: result.title ?? input.title ?? `Generated ${input.kind}`
+      });
+      return artifact;
+    },
+    kinds: () => [...generators.keys()],
+    register: (generator) => {
+      generators.set(generator.kind, generator);
+    }
+  };
+};
+// src/standardKinds.ts
+import { Type } from "@sinclair/typebox";
+var FileArtifactContentSchema = Type.Object({
+  description: Type.Optional(Type.String()),
+  instructions: Type.Optional(Type.String()),
+  summary: Type.Optional(Type.String())
+});
+var capabilities = [
+  "attach",
+  "archive",
+  "edit",
+  "export",
+  "preview",
+  "refine"
+];
+var fileKind = (label, acceptedMediaTypes, maxCount = 1) => ({
+  assets: { acceptedMediaTypes, maxCount },
+  capabilities: [...capabilities],
+  content: FileArtifactContentSchema,
+  label,
+  schemaVersion: 1
+});
+var standardArtifactDefinitions = {
+  archive: fileKind("Archive", [
+    "application/gzip",
+    "application/vnd.rar",
+    "application/x-7z-compressed",
+    "application/x-bzip2",
+    "application/x-tar",
+    "application/zip"
+  ], 20),
+  audio: fileKind("Audio", ["audio/*"]),
+  code: fileKind("Code", ["application/json", "application/xml", "text/*"], 100),
+  dataset: fileKind("Dataset", [
+    "application/json",
+    "application/x-ndjson",
+    "application/xml",
+    "text/csv",
+    "text/tab-separated-values",
+    "text/plain",
+    "text/yaml"
+  ], 20),
+  document: fileKind("Document", [
+    "application/epub+zip",
+    "application/msword",
+    "application/pdf",
+    "application/rtf",
+    "application/vnd.oasis.opendocument.text",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    "text/*"
+  ], 20),
+  email: fileKind("Email", ["application/mbox", "application/vnd.ms-outlook", "message/*", "text/*"], 100),
+  file: fileKind("File", ["*/*"], 100),
+  image: fileKind("Image", ["image/*"], 20),
+  presentation: fileKind("Presentation", [
+    "application/pdf",
+    "application/vnd.ms-powerpoint",
+    "application/vnd.oasis.opendocument.presentation",
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+  ], 20),
+  spreadsheet: fileKind("Spreadsheet", [
+    "application/vnd.ms-excel",
+    "application/vnd.oasis.opendocument.spreadsheet",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    "text/csv",
+    "text/tab-separated-values"
+  ], 20),
+  video: fileKind("Video", ["video/*"])
+};
+var STANDARD_ARTIFACT_KIND_NAMES = Object.keys(standardArtifactDefinitions);
 // src/renderers.ts
 var createArtifactRendererRegistry = (initial = []) => {
   const key = (kind, format) => `${kind}:${format}`;
@@ -55,84 +169,327 @@ var requireCapability = (artifact, capability) => {
     throw new ArtifactError("unsupported_capability", `${artifact.kind} artifacts do not support ${capability}`);
   }
 };
+var mediaTypeMatches = (accepted, actual) => {
+  if (accepted === "*/*" || accepted === actual)
+    return true;
+  if (!accepted.endsWith("/*"))
+    return false;
+  return actual.startsWith(accepted.slice(0, -1));
+};
 var createArtifactService = (options) => {
   const now = () => (options.clock ?? (() => new Date))().toISOString();
   const idFactory = options.idFactory ?? (() => crypto.randomUUID());
+  const eventIdFactory = options.eventIdFactory ?? (() => crypto.randomUUID());
+  const event = (artifact, type, payload) => ({
+    artifactId: artifact.id,
+    createdAt: now(),
+    id: eventIdFactory(),
+    ownerId: artifact.ownerId,
+    payload,
+    revision: artifact.revision,
+    type
+  });
+  const validateAssets = (kind, assets) => {
+    const policy = options.registry.definitions[kind]?.assets;
+    if (!policy) {
+      if (assets.length > 0) {
+        throw new ArtifactError("invalid_content", `${kind} artifacts do not accept file assets`);
+      }
+      return assets;
+    }
+    if (policy.maxCount !== undefined && assets.length > policy.maxCount) {
+      throw new ArtifactError("invalid_content", `${kind} artifacts accept at most ${policy.maxCount} file assets`);
+    }
+    const rejected = assets.find((asset) => policy.acceptedMediaTypes?.length && !policy.acceptedMediaTypes.some((accepted) => mediaTypeMatches(accepted, asset.mediaType)));
+    if (rejected) {
+      throw new ArtifactError("invalid_content", `${rejected.mediaType} is not accepted by ${kind} artifacts`);
+    }
+    return assets;
+  };
+  const validateAssetInputs = (kind, inputs, currentCount = 0) => {
+    const policy = options.registry.definitions[kind]?.assets;
+    if (!policy && inputs.length > 0) {
+      throw new ArtifactError("invalid_content", `${kind} artifacts do not accept file assets`);
+    }
+    if (policy?.maxCount !== undefined && currentCount + inputs.length > policy.maxCount) {
+      throw new ArtifactError("invalid_content", `${kind} artifacts accept at most ${policy.maxCount} file assets`);
+    }
+    const rejected = inputs.find((input) => policy?.acceptedMediaTypes?.length && !policy.acceptedMediaTypes.some((accepted) => mediaTypeMatches(accepted, input.mediaType)));
+    if (rejected) {
+      throw new ArtifactError("invalid_content", `${rejected.mediaType} is not accepted by ${kind} artifacts`);
+    }
+  };
+  const buildRecord = (ownerId, input, assets) => {
+    const definition = options.registry.definitions[input.kind];
+    if (!definition) {
+      throw new ArtifactError("unknown_kind", `Unknown artifact kind: ${input.kind}`);
+    }
+    const timestamp = now();
+    const artifact = {
+      assets: validateAssets(input.kind, assets),
+      capabilities: definition.capabilities ?? ["archive", "edit", "preview"],
+      content: options.registry.parse(input.kind, input.content),
+      createdAt: timestamp,
+      createdBy: input.createdBy,
+      id: idFactory(),
+      kind: input.kind,
+      metadata: input.metadata ?? {},
+      ownerId,
+      provenance: input.provenance,
+      revision: 1,
+      schemaVersion: definition.schemaVersion ?? 1,
+      status: "draft",
+      title: input.title.trim(),
+      updatedAt: timestamp
+    };
+    return artifact;
+  };
   const get = async (ownerId, artifactId) => {
     const artifact = await options.store.get(ownerId, artifactId);
-    if (!artifact) {
+    if (!artifact)
       throw new ArtifactError("not_found", "Artifact not found");
-    }
     return artifact;
   };
-  const saveRevision = async (artifact, expectedRevision) => {
-    const saved = await options.store.save(artifact, expectedRevision);
+  const saveRevision = async (artifact, expectedRevision, type, payload) => {
+    const saved = await options.store.save(artifact, expectedRevision, [
+      event(artifact, type, payload)
+    ]);
     if (!saved) {
       throw new ArtifactError("conflict", "Artifact changed since it was opened; reload before saving");
     }
     return artifact;
   };
-  return {
+  const requireAssetTransactions = () => {
+    if (!options.assetStore?.stage) {
+      throw new ArtifactError("asset_transaction_unavailable", "The configured artifact asset store does not support atomic bundles");
+    }
+    return options.assetStore;
+  };
+  const service = {
     archive: async (ownerId, artifactId) => {
       const current = await get(ownerId, artifactId);
       requireCapability(current, "archive");
-      return saveRevision({
+      const archived = {
         ...current,
         revision: current.revision + 1,
         status: "archived",
         updatedAt: now()
-      }, current.revision);
+      };
+      return saveRevision(archived, current.revision, "artifact.archived");
+    },
+    attach: async (ownerId, artifactId, input, expectedRevision) => {
+      const current = await get(ownerId, artifactId);
+      requireCapability(current, "attach");
+      validateAssetInputs(current.kind, [input], current.assets.length);
+      if (!options.assetStore) {
+        throw new ArtifactError("asset_store_unavailable", "No artifact asset store is configured");
+      }
+      const reference = await options.assetStore.write(input, {
+        artifact: current,
+        idempotencyKey: `artifact:${current.id}:asset:${current.revision + 1}`
+      });
+      return saveRevision({
+        ...current,
+        assets: validateAssets(current.kind, [...current.assets, reference]),
+        revision: current.revision + 1,
+        updatedAt: now()
+      }, expectedRevision ?? current.revision, "artifact.asset_attached", { assetIds: [reference.id] });
+    },
+    attachBundle: async (ownerId, artifactId, inputs, expectedRevision) => {
+      const current = await get(ownerId, artifactId);
+      requireCapability(current, "attach");
+      validateAssetInputs(current.kind, inputs, current.assets.length);
+      const assetStore = requireAssetTransactions();
+      const transaction = await assetStore.stage(inputs, {
+        artifact: current,
+        idempotencyKey: `artifact:${current.id}:bundle:${current.revision + 1}`
+      });
+      const assets = validateAssets(current.kind, [
+        ...current.assets,
+        ...transaction.references
+      ]);
+      const revised = {
+        ...current,
+        assets,
+        revision: current.revision + 1,
+        updatedAt: now()
+      };
+      try {
+        await transaction.commit();
+        return await saveRevision(revised, expectedRevision ?? current.revision, "artifact.asset_attached", { assetIds: transaction.references.map((asset) => asset.id) });
+      } catch (error) {
+        await transaction.rollback();
+        throw error;
+      }
+    },
+    collectAssetGarbage: async (input) => {
+      if (!options.assetStore) {
+        throw new ArtifactError("asset_store_unavailable", "No artifact asset store is configured");
+      }
+      const referenced = new Set(await options.store.listReferencedAssetIds());
+      const cutoff = Date.now() - (input.minimumAgeMs ?? 0);
+      const candidates = await options.assetStore.listCandidates();
+      const deleted = [];
+      const retained = [];
+      for (const candidate of candidates) {
+        if (referenced.has(candidate.reference.id) || new Date(candidate.createdAt).getTime() > cutoff) {
+          retained.push(candidate.reference);
+        } else {
+          deleted.push(candidate.reference);
+          if (!input.dryRun)
+            await options.assetStore.delete(candidate.reference);
+        }
+      }
+      return { deleted, retained };
     },
     create: async (ownerId, input) => {
-      const definition = options.registry.definitions[input.kind];
-      if (!definition) {
-        throw new ArtifactError("unknown_kind", `Unknown artifact kind: ${input.kind}`);
+      const artifact = buildRecord(ownerId, input, input.assets ?? []);
+      await options.store.create(artifact, [
+        event(artifact, "artifact.created")
+      ]);
+      return artifact;
+    },
+    createBundle: async (ownerId, input) => {
+      const { assets: assetInputs = [], ...createInput } = input;
+      validateAssetInputs(input.kind, assetInputs);
+      if (assetInputs.length === 0) {
+        return service.create(ownerId, createInput);
       }
-      const content = options.registry.parse(input.kind, input.content);
-      const timestamp = now();
+      const assetStore = requireAssetTransactions();
+      const provisional = buildRecord(ownerId, createInput, []);
+      const transaction = await assetStore.stage(assetInputs, {
+        artifact: provisional,
+        idempotencyKey: `artifact:${provisional.id}:bundle:1`
+      });
       const artifact = {
-        capabilities: definition.capabilities ?? ["archive", "edit", "preview"],
-        content,
-        createdAt: timestamp,
-        createdBy: input.createdBy,
-        id: idFactory(),
-        kind: input.kind,
-        metadata: input.metadata ?? {},
-        ownerId,
-        provenance: input.provenance,
-        revision: 1,
-        schemaVersion: definition.schemaVersion ?? 1,
-        status: "draft",
-        title: input.title.trim(),
-        updatedAt: timestamp
+        ...provisional,
+        assets: validateAssets(input.kind, transaction.references)
       };
-      await options.store.create(artifact);
-      return artifact;
+      try {
+        await transaction.commit();
+        await options.store.create(artifact, [
+          event(artifact, "artifact.created"),
+          event(artifact, "artifact.generated", {
+            assetIds: transaction.references.map((asset) => asset.id)
+          })
+        ]);
+        return artifact;
+      } catch (error) {
+        await transaction.rollback();
+        throw error;
+      }
+    },
+    detach: async (ownerId, artifactId, assetId, expectedRevision) => {
+      const current = await get(ownerId, artifactId);
+      requireCapability(current, "attach");
+      const assets = current.assets.filter((asset) => asset.id !== assetId);
+      if (assets.length === current.assets.length) {
+        throw new ArtifactError("not_found", "Artifact asset not found");
+      }
+      return saveRevision({
+        ...current,
+        assets,
+        revision: current.revision + 1,
+        updatedAt: now()
+      }, expectedRevision ?? current.revision, "artifact.asset_detached", { assetId });
     },
     get,
+    getIndexingState: (ownerId, artifactId) => options.store.getIndexingState(ownerId, artifactId),
+    getRevision: async (ownerId, artifactId, revision) => {
+      const snapshot = await options.store.getRevision(ownerId, artifactId, revision);
+      if (!snapshot) {
+        throw new ArtifactError("not_found", "Artifact revision not found");
+      }
+      return snapshot;
+    },
     list: (ownerId, query) => options.store.list(ownerId, query),
-    publish: async (ownerId, artifactId) => {
+    listEvents: (query) => options.store.listEvents(query),
+    listRevisions: (ownerId, artifactId) => options.store.listRevisions(ownerId, artifactId),
+    markEventProcessed: (eventId, processedAt = now()) => options.store.markEventProcessed(eventId, processedAt),
+    markIndexing: async (ownerId, artifactId, input) => {
+      const artifact = await get(ownerId, artifactId);
+      const state = {
+        artifactId,
+        documentIds: input.documentIds ?? [],
+        error: input.error,
+        indexedAt: input.status === "indexed" ? now() : undefined,
+        revision: input.revision,
+        status: input.status,
+        updatedAt: now()
+      };
+      await options.store.putIndexingState(ownerId, state, [
+        event(artifact, "artifact.indexing_changed", {
+          indexingRevision: state.revision,
+          indexingStatus: state.status
+        })
+      ]);
+      return state;
+    },
+    publish: async (ownerId, artifactId, input = {}) => {
       const current = await get(ownerId, artifactId);
       requireCapability(current, "publish");
       if (!options.publisher) {
         throw new ArtifactError("publisher_unavailable", "No artifact publisher is configured");
       }
+      const mode = input.mode ?? "pinned";
+      const publishedRevision = current.revision;
       const result = await options.publisher.publish(current, {
-        idempotencyKey: `artifact:${current.id}:publish:${current.revision + 1}`
+        idempotencyKey: `artifact:${current.id}:publish:${publishedRevision}:${mode}`,
+        mode,
+        revision: publishedRevision
       });
       const publishedAt = now();
       const publication = {
         id: result.id,
+        mode,
         publishedAt,
+        revision: publishedRevision,
         url: result.url
       };
-      return saveRevision({
+      const published = {
         ...current,
         publication,
         revision: current.revision + 1,
         status: "published",
         updatedAt: publishedAt
-      }, current.revision);
+      };
+      return saveRevision(published, current.revision, "artifact.published", {
+        mode,
+        publishedRevision
+      });
+    },
+    readAsset: async (ownerId, artifactId, assetId) => {
+      const artifact = await get(ownerId, artifactId);
+      const asset = artifact.assets.find((candidate) => candidate.id === assetId);
+      if (!asset)
+        throw new ArtifactError("not_found", "Artifact asset not found");
+      if (!options.assetStore) {
+        throw new ArtifactError("asset_store_unavailable", "No artifact asset store is configured");
+      }
+      return {
+        asset,
+        data: await options.assetStore.read(asset, { artifact })
+      };
+    },
+    restore: async (ownerId, artifactId, revision, expectedRevision) => {
+      const current = await get(ownerId, artifactId);
+      requireCapability(current, "edit");
+      const snapshot = await options.store.getRevision(ownerId, artifactId, revision);
+      if (!snapshot) {
+        throw new ArtifactError("not_found", "Artifact revision not found");
+      }
+      return saveRevision({
+        ...current,
+        assets: validateAssets(current.kind, snapshot.assets),
+        content: options.registry.parse(current.kind, snapshot.content),
+        metadata: snapshot.metadata,
+        publication: undefined,
+        provenance: snapshot.provenance,
+        revision: current.revision + 1,
+        status: "draft",
+        title: snapshot.title,
+        updatedAt: now()
+      }, expectedRevision ?? current.revision, "artifact.restored", { restoredRevision: revision });
     },
     unpublish: async (ownerId, artifactId) => {
       const current = await get(ownerId, artifactId);
@@ -149,51 +506,198 @@ var createArtifactService = (options) => {
         revision: current.revision + 1,
         status: "draft",
         updatedAt: now()
-      }, current.revision);
+      }, current.revision, "artifact.unpublished");
     },
     update: async (ownerId, artifactId, input) => {
       const current = await get(ownerId, artifactId);
       requireCapability(current, "edit");
-      const expectedRevision = input.expectedRevision ?? current.revision;
-      const content = input.content === undefined ? current.content : options.registry.parse(current.kind, input.content);
+      const nextRevision = current.revision + 1;
+      const publication = current.publication?.mode === "live" ? { ...current.publication, revision: nextRevision } : current.publication;
       return saveRevision({
         ...current,
-        content,
+        assets: input.assets === undefined ? current.assets : validateAssets(current.kind, input.assets),
+        content: input.content === undefined ? current.content : options.registry.parse(current.kind, input.content),
         metadata: input.metadata ?? current.metadata,
-        revision: current.revision + 1,
+        publication,
+        revision: nextRevision,
         title: input.title?.trim() || current.title,
         updatedAt: now()
-      }, expectedRevision);
+      }, input.expectedRevision ?? current.revision, "artifact.revised");
     }
   };
+  return service;
 };
 // src/store.ts
+import { createHash } from "crypto";
 var clone = (value) => structuredClone(value);
+var createMemoryArtifactAssetStore = () => {
+  const bytes = new Map;
+  const references = new Map;
+  const idempotency = new Map;
+  return {
+    delete: async (reference) => {
+      bytes.delete(reference.id);
+      references.delete(reference.id);
+    },
+    listCandidates: async () => [...references.values()].map((reference) => ({
+      createdAt: reference.createdAt,
+      reference: clone(reference)
+    })),
+    read: async (reference) => {
+      const data = bytes.get(reference.id);
+      if (!data)
+        throw new Error(`Artifact asset not found: ${reference.id}`);
+      return clone(data);
+    },
+    write: async (input, context) => {
+      const existingId = idempotency.get(context.idempotencyKey);
+      if (existingId)
+        return clone(references.get(existingId));
+      const id = crypto.randomUUID();
+      const reference = {
+        checksum: {
+          algorithm: "sha256",
+          value: createHash("sha256").update(input.data).digest("hex")
+        },
+        createdAt: new Date().toISOString(),
+        id,
+        mediaType: input.mediaType,
+        metadata: input.metadata,
+        name: input.name,
+        role: input.role ?? "attachment",
+        size: input.data.byteLength,
+        uri: `memory://${id}`
+      };
+      bytes.set(id, clone(input.data));
+      references.set(id, clone(reference));
+      idempotency.set(context.idempotencyKey, id);
+      return reference;
+    },
+    stage: async (inputs, context) => {
+      const staged = inputs.map((input, index) => {
+        const key = `${context.idempotencyKey}:${index}`;
+        const existingId = idempotency.get(key);
+        if (existingId) {
+          return {
+            data: bytes.get(existingId),
+            key,
+            reference: references.get(existingId)
+          };
+        }
+        const id = crypto.randomUUID();
+        const reference = {
+          checksum: {
+            algorithm: "sha256",
+            value: createHash("sha256").update(input.data).digest("hex")
+          },
+          createdAt: new Date().toISOString(),
+          id,
+          mediaType: input.mediaType,
+          metadata: input.metadata,
+          name: input.name,
+          role: input.role ?? "attachment",
+          size: input.data.byteLength,
+          uri: `memory://${id}`
+        };
+        return { data: clone(input.data), key, reference };
+      });
+      return {
+        commit: async () => {
+          for (const item of staged) {
+            bytes.set(item.reference.id, clone(item.data));
+            references.set(item.reference.id, clone(item.reference));
+            idempotency.set(item.key, item.reference.id);
+          }
+        },
+        references: staged.map((item) => clone(item.reference)),
+        rollback: async () => {
+          for (const item of staged) {
+            bytes.delete(item.reference.id);
+            references.delete(item.reference.id);
+            idempotency.delete(item.key);
+          }
+        }
+      };
+    }
+  };
+};
 var createMemoryArtifactStore = (initial = []) => {
   const records = new Map(initial.map((record) => [record.id, clone(record)]));
+  const revisions = new Map;
+  const events = new Map;
+  const indexing = new Map;
+  for (const record of initial)
+    revisions.set(record.id, [clone(record)]);
   return {
-    create: async (record) => {
+    create: async (record, newEvents = []) => {
       if (records.has(record.id))
         throw new Error(`Duplicate artifact id: ${record.id}`);
       records.set(record.id, clone(record));
+      revisions.set(record.id, [clone(record)]);
+      for (const event of newEvents)
+        events.set(event.id, clone(event));
     },
     get: async (ownerId, artifactId) => {
       const record = records.get(artifactId);
       return record?.ownerId === ownerId ? clone(record) : null;
     },
+    getIndexingState: async (ownerId, artifactId) => {
+      const record = records.get(artifactId);
+      if (record?.ownerId !== ownerId)
+        return null;
+      return clone(indexing.get(artifactId) ?? null);
+    },
+    getRevision: async (ownerId, artifactId, revision) => {
+      const current = records.get(artifactId);
+      if (current?.ownerId !== ownerId)
+        return null;
+      return clone(revisions.get(artifactId)?.find((candidate) => candidate.revision === revision) ?? null);
+    },
     list: async (ownerId, query = {}) => [...records.values()].filter((record) => record.ownerId === ownerId && (!query.kind || record.kind === query.kind) && (!query.status || record.status === query.status)).sort((left, right) => right.updatedAt.localeCompare(left.updatedAt)).slice(0, query.limit ?? Number.POSITIVE_INFINITY).map(clone),
-    save: async (record, expectedRevision) => {
+    listRevisions: async (ownerId, artifactId) => {
+      const current = records.get(artifactId);
+      if (current?.ownerId !== ownerId)
+        return [];
+      return (revisions.get(artifactId) ?? []).toSorted((left, right) => right.revision - left.revision).map(clone);
+    },
+    listEvents: async (query = {}) => [...events.values()].filter((event) => (query.processed === undefined || Boolean(event.processedAt) === query.processed) && (!query.type || event.type === query.type)).sort((left, right) => left.createdAt.localeCompare(right.createdAt)).slice(0, query.limit ?? Number.POSITIVE_INFINITY).map(clone),
+    listReferencedAssetIds: async () => [
+      ...new Set([...revisions.values()].flat().flatMap((revision) => revision.assets.map((asset) => asset.id)))
+    ],
+    markEventProcessed: async (eventId, processedAt) => {
+      const event = events.get(eventId);
+      if (!event)
+        return false;
+      events.set(eventId, { ...event, processedAt });
+      return true;
+    },
+    putIndexingState: async (ownerId, state, newEvents = []) => {
+      const record = records.get(state.artifactId);
+      if (record?.ownerId !== ownerId) {
+        throw new Error("Artifact not found");
+      }
+      indexing.set(state.artifactId, clone(state));
+      for (const event of newEvents)
+        events.set(event.id, clone(event));
+    },
+    save: async (record, expectedRevision, newEvents = []) => {
       const current = records.get(record.id);
       if (!current || current.ownerId !== record.ownerId || current.revision !== expectedRevision) {
         return false;
       }
       records.set(record.id, clone(record));
+      revisions.set(record.id, [
+        ...revisions.get(record.id) ?? [],
+        clone(record)
+      ]);
+      for (const event of newEvents)
+        events.set(event.id, clone(event));
       return true;
     }
   };
 };
 // src/tools.ts
-import { Type } from "@sinclair/typebox";
+import { Type as Type2 } from "@sinclair/typebox";
 var record = (input) => input && typeof input === "object" && !Array.isArray(input) ? input : {};
 var stringValue = (input, key) => typeof input[key] === "string" ? input[key] : undefined;
 var createArtifactTools = (options) => ({
@@ -214,10 +718,10 @@ var createArtifactTools = (options) => ({
       });
       return JSON.stringify(artifact);
     },
-    input: Type.Object({
-      content: Type.Unknown(),
-      kind: Type.String({ minLength: 1 }),
-      title: Type.String({ minLength: 1 })
+    input: Type2.Object({
+      content: Type2.Unknown(),
+      kind: Type2.String({ minLength: 1 }),
+      title: Type2.String({ minLength: 1 })
     })
   },
   artifact_get: {
@@ -229,7 +733,7 @@ var createArtifactTools = (options) => ({
         return "Provide artifactId.";
       return JSON.stringify(await options.service.get(options.ownerId, artifactId));
     },
-    input: Type.Object({ artifactId: Type.String({ minLength: 1 }) })
+    input: Type2.Object({ artifactId: Type2.String({ minLength: 1 }) })
   },
   artifact_list: {
     annotations: { readOnlyHint: true },
@@ -242,11 +746,22 @@ var createArtifactTools = (options) => ({
         status: ARTIFACT_STATUSES.find((candidate) => candidate === status)
       }));
     },
-    input: Type.Object({
-      kind: Type.Optional(Type.String()),
-      status: Type.Optional(Type.Union(ARTIFACT_STATUSES.map((status) => Type.Literal(status))))
+    input: Type2.Object({
+      kind: Type2.Optional(Type2.String()),
+      status: Type2.Optional(Type2.Union(ARTIFACT_STATUSES.map((status) => Type2.Literal(status))))
     })
   },
+  artifact_history: {
+    annotations: { readOnlyHint: true },
+    description: "List the immutable revisions of one owned artifact.",
+    handler: async (raw) => {
+      const artifactId = stringValue(record(raw), "artifactId");
+      if (!artifactId)
+        return "Provide artifactId.";
+      return JSON.stringify(await options.service.listRevisions(options.ownerId, artifactId));
+    },
+    input: Type2.Object({ artifactId: Type2.String({ minLength: 1 }) })
+  },
   artifact_publish: {
     description: "Publish or unpublish an artifact. Hosts should expose this tool only when the user explicitly controls public access.",
     handler: async (raw) => {
@@ -255,12 +770,31 @@ var createArtifactTools = (options) => ({
       if (!artifactId || typeof input.published !== "boolean") {
         return "Provide artifactId and published.";
       }
-      const artifact = input.published ? await options.service.publish(options.ownerId, artifactId) : await options.service.unpublish(options.ownerId, artifactId);
+      const artifact = input.published ? await options.service.publish(options.ownerId, artifactId, {
+        mode: input.mode === "live" ? "live" : "pinned"
+      }) : await options.service.unpublish(options.ownerId, artifactId);
       return JSON.stringify(artifact);
     },
-    input: Type.Object({
-      artifactId: Type.String({ minLength: 1 }),
-      published: Type.Boolean()
+    input: Type2.Object({
+      artifactId: Type2.String({ minLength: 1 }),
+      mode: Type2.Optional(Type2.Union([Type2.Literal("live"), Type2.Literal("pinned")])),
+      published: Type2.Boolean()
+    })
+  },
+  artifact_restore: {
+    description: "Restore an immutable artifact revision as a new private draft revision.",
+    handler: async (raw) => {
+      const input = record(raw);
+      const artifactId = stringValue(input, "artifactId");
+      if (!artifactId || typeof input.revision !== "number") {
+        return "Provide artifactId and revision.";
+      }
+      return JSON.stringify(await options.service.restore(options.ownerId, artifactId, input.revision, typeof input.expectedRevision === "number" ? input.expectedRevision : undefined));
+    },
+    input: Type2.Object({
+      artifactId: Type2.String({ minLength: 1 }),
+      expectedRevision: Type2.Optional(Type2.Integer({ minimum: 1 })),
+      revision: Type2.Integer({ minimum: 1 })
     })
   },
   artifact_update: {
@@ -277,20 +811,25 @@ var createArtifactTools = (options) => ({
       });
       return JSON.stringify(artifact);
     },
-    input: Type.Object({
-      artifactId: Type.String({ minLength: 1 }),
-      content: Type.Optional(Type.Unknown()),
-      expectedRevision: Type.Optional(Type.Integer({ minimum: 1 })),
-      title: Type.Optional(Type.String({ minLength: 1 }))
+    input: Type2.Object({
+      artifactId: Type2.String({ minLength: 1 }),
+      content: Type2.Optional(Type2.Unknown()),
+      expectedRevision: Type2.Optional(Type2.Integer({ minimum: 1 })),
+      title: Type2.Optional(Type2.String({ minLength: 1 }))
     })
   }
 });
 export {
+  standardArtifactDefinitions,
   defineArtifactRegistry,
   createMemoryArtifactStore,
+  createMemoryArtifactAssetStore,
   createArtifactTools,
   createArtifactService,
   createArtifactRendererRegistry,
+  createArtifactGeneratorRegistry,
+  STANDARD_ARTIFACT_KIND_NAMES,
   ArtifactError,
-  ARTIFACT_STATUSES
+  ARTIFACT_STATUSES,
+  ARTIFACT_EVENT_TYPES
 };