@absolutejs/artifacts 0.0.1 → 0.0.3

package/dist/manifest.js

@@ -5954,6 +5954,24 @@ var manifest = defineManifest()({
         kind: Type2.Optional(Type2.String({ minLength: 1 })),
         ownerId: Type2.String({ minLength: 1 })
       })
+    }),
+    artifact_history: tool.runtime({
+      annotations: { readOnlyHint: true },
+      description: "List immutable revisions of one artifact owned by a user.",
+      handler: async ({ artifactId, ownerId }, service) => JSON.stringify(await service.listRevisions(ownerId, artifactId)),
+      input: Type2.Object({
+        artifactId: Type2.String({ minLength: 1 }),
+        ownerId: Type2.String({ minLength: 1 })
+      })
+    }),
+    artifact_restore: tool.runtime({
+      description: "Restore an old artifact revision as a new private draft.",
+      handler: async ({ artifactId, ownerId, revision }, service) => JSON.stringify(await service.restore(ownerId, artifactId, revision)),
+      input: Type2.Object({
+        artifactId: Type2.String({ minLength: 1 }),
+        ownerId: Type2.String({ minLength: 1 }),
+        revision: Type2.Integer({ minimum: 1 })
+      })
     })
   },
   wiring: [

package/dist/manifest.json

@@ -95,6 +95,56 @@
 				}
 			},
 			"kind": "runtime"
+		},
+		"artifact_history": {
+			"annotations": {
+				"readOnlyHint": true
+			},
+			"description": "List immutable revisions of one artifact owned by a user.",
+			"input": {
+				"type": "object",
+				"required": [
+					"artifactId",
+					"ownerId"
+				],
+				"properties": {
+					"artifactId": {
+						"minLength": 1,
+						"type": "string"
+					},
+					"ownerId": {
+						"minLength": 1,
+						"type": "string"
+					}
+				}
+			},
+			"kind": "runtime"
+		},
+		"artifact_restore": {
+			"description": "Restore an old artifact revision as a new private draft.",
+			"input": {
+				"type": "object",
+				"required": [
+					"artifactId",
+					"ownerId",
+					"revision"
+				],
+				"properties": {
+					"artifactId": {
+						"minLength": 1,
+						"type": "string"
+					},
+					"ownerId": {
+						"minLength": 1,
+						"type": "string"
+					},
+					"revision": {
+						"minimum": 1,
+						"type": "integer"
+					}
+				}
+			},
+			"kind": "runtime"
 		}
 	}
 }

package/dist/rag.js

@@ -0,0 +1,76 @@
+// @bun
+// src/rag.ts
+import { Buffer } from "buffer";
+var artifactMetadata = (artifact) => ({
+  artifactId: artifact.id,
+  artifactKind: artifact.kind,
+  artifactRevision: artifact.revision,
+  artifactStatus: artifact.status,
+  ...artifact.metadata
+});
+var artifactToRAGUploads = async (artifact, reader, options = {}) => {
+  const metadata = artifactMetadata(artifact);
+  const uploads = await Promise.all(artifact.assets.map(async (asset) => ({
+    content: Buffer.from(await reader.read(asset, { artifact })).toString("base64"),
+    contentType: asset.mediaType,
+    encoding: "base64",
+    metadata: {
+      ...metadata,
+      artifactAssetId: asset.id,
+      artifactAssetRole: asset.role,
+      ...asset.metadata
+    },
+    name: asset.name,
+    source: `artifact:${artifact.id}:revision:${artifact.revision}:asset:${asset.id}`,
+    title: artifact.title
+  })));
+  if (options.includeStructuredContent === false)
+    return uploads;
+  return [
+    {
+      content: JSON.stringify(artifact.content),
+      contentType: "application/json",
+      encoding: "utf8",
+      metadata: { ...metadata, artifactStructuredContent: true },
+      name: `${artifact.kind}-${artifact.id}-r${artifact.revision}.json`,
+      source: `artifact:${artifact.id}:revision:${artifact.revision}:content`,
+      title: artifact.title
+    },
+    ...uploads
+  ];
+};
+var createArtifactRAGIndexCoordinator = (options) => ({
+  index: async (artifact) => {
+    const previous = await options.service.getIndexingState(artifact.ownerId, artifact.id);
+    await options.service.markIndexing(artifact.ownerId, artifact.id, {
+      documentIds: previous?.documentIds,
+      revision: artifact.revision,
+      status: "pending"
+    });
+    try {
+      const uploads = await artifactToRAGUploads(artifact, options.reader);
+      const indexed = await options.target.index(uploads, { artifact });
+      if (previous?.documentIds.length && options.target.remove) {
+        await options.target.remove(previous.documentIds, { artifact });
+      }
+      await options.service.markIndexing(artifact.ownerId, artifact.id, {
+        documentIds: indexed.documentIds,
+        revision: artifact.revision,
+        status: "indexed"
+      });
+      return indexed;
+    } catch (error) {
+      await options.service.markIndexing(artifact.ownerId, artifact.id, {
+        documentIds: previous?.documentIds,
+        error: error instanceof Error ? error.message : String(error),
+        revision: artifact.revision,
+        status: "failed"
+      });
+      throw error;
+    }
+  }
+});
+export {
+  createArtifactRAGIndexCoordinator,
+  artifactToRAGUploads
+};

package/dist/src/generators.d.ts

@@ -0,0 +1,34 @@
+import type { ArtifactAssetWriteInput, ArtifactBundleCreateInput, ArtifactProvenance, ArtifactRecord } from "./types";
+export type ArtifactGenerationInput = {
+    createdBy: string;
+    input?: Record<string, unknown>;
+    kind: string;
+    ownerId: string;
+    prompt?: string;
+    title?: string;
+};
+export type ArtifactGenerationContext = {
+    ownerId: string;
+};
+export type ArtifactGenerationResult = {
+    assets?: ArtifactAssetWriteInput[];
+    content: unknown;
+    metadata?: Record<string, unknown>;
+    provenance?: ArtifactProvenance;
+    title?: string;
+    warnings?: string[];
+};
+export type ArtifactGenerator = {
+    generate(input: ArtifactGenerationInput, context: ArtifactGenerationContext): Promise<ArtifactGenerationResult>;
+    kind: string;
+    name: string;
+};
+export type ArtifactBundleCreator = {
+    createBundle(ownerId: string, input: ArtifactBundleCreateInput): Promise<ArtifactRecord>;
+};
+export declare const createArtifactGeneratorRegistry: (initial?: ArtifactGenerator[]) => {
+    generate: (service: ArtifactBundleCreator, input: ArtifactGenerationInput) => Promise<ArtifactRecord>;
+    kinds: () => string[];
+    register: (generator: ArtifactGenerator) => void;
+};
+export type ArtifactGeneratorRegistry = ReturnType<typeof createArtifactGeneratorRegistry>;

package/dist/src/index.d.ts

@@ -7,8 +7,10 @@
  * retains authorization, persistence, URLs, UI, and delivery policy.
  */
 export { defineArtifactRegistry, type ArtifactContent, type ArtifactKindDefinition, type ArtifactKindDefinitions, type ArtifactRegistry, } from "./registry";
+export { createArtifactGeneratorRegistry, type ArtifactBundleCreator, type ArtifactGenerationContext, type ArtifactGenerationInput, type ArtifactGenerationResult, type ArtifactGenerator, type ArtifactGeneratorRegistry, } from "./generators";
+export { STANDARD_ARTIFACT_KIND_NAMES, standardArtifactDefinitions, } from "./standardKinds";
 export { createArtifactRendererRegistry, type ArtifactRenderer, type ArtifactRendererRegistry, type ArtifactRenderResult, } from "./renderers";
 export { createArtifactService, type ArtifactPublisher, type ArtifactService, type ArtifactServiceOptions, } from "./service";
-export { createMemoryArtifactStore, type ArtifactStore } from "./store";
+export { createMemoryArtifactStore, createMemoryArtifactAssetStore, type ArtifactAssetStore, type ArtifactAssetTransaction, type ArtifactStore, } from "./store";
 export { createArtifactTools, type ArtifactToolDefinition, type ArtifactToolMap, type ArtifactToolOptions, } from "./tools";
-export { ARTIFACT_STATUSES, ArtifactError, type ArtifactCapability, type ArtifactCreateInput, type ArtifactErrorCode, type ArtifactListQuery, type ArtifactProvenance, type ArtifactPublication, type ArtifactRecord, type ArtifactStatus, type ArtifactUpdateInput, } from "./types";
+export { ARTIFACT_STATUSES, ARTIFACT_EVENT_TYPES, ArtifactError, type ArtifactAssetReference, type ArtifactAssetRole, type ArtifactAssetWriteInput, type ArtifactBundleCreateInput, type ArtifactCapability, type ArtifactCreateInput, type ArtifactErrorCode, type ArtifactEvent, type ArtifactEventQuery, type ArtifactEventType, type ArtifactGarbageCollectionResult, type ArtifactIndexingState, type ArtifactIndexingStatus, type ArtifactListQuery, type ArtifactLineageReference, type ArtifactLineageRelation, type ArtifactProvenance, type ArtifactPublication, type ArtifactPublishInput, type ArtifactRecord, type ArtifactRevision, type ArtifactRetentionCandidate, type ArtifactStatus, type ArtifactUpdateInput, } from "./types";

package/dist/src/manifest.d.ts

@@ -1,9 +1,33 @@
 export declare const manifest: import("@absolutejs/manifest").PackageManifest<Record<string, never>, {
     archive: (ownerId: string, artifactId: string) => Promise<import("./types").ArtifactRecord>;
+    attach: (ownerId: string, artifactId: string, input: import("./types").ArtifactAssetWriteInput, expectedRevision?: number) => Promise<import("./types").ArtifactRecord>;
+    attachBundle: (ownerId: string, artifactId: string, inputs: import("./types").ArtifactAssetWriteInput[], expectedRevision?: number) => Promise<import("./types").ArtifactRecord>;
+    collectAssetGarbage: (input: {
+        dryRun?: boolean;
+        minimumAgeMs?: number;
+    }) => Promise<import("./types").ArtifactGarbageCollectionResult>;
     create: (ownerId: string, input: import("./types").ArtifactCreateInput) => Promise<import("./types").ArtifactRecord>;
+    createBundle: (ownerId: string, input: import("./types").ArtifactBundleCreateInput) => Promise<import("./types").ArtifactRecord>;
+    detach: (ownerId: string, artifactId: string, assetId: string, expectedRevision?: number) => Promise<import("./types").ArtifactRecord>;
     get: (ownerId: string, artifactId: string) => Promise<import("./types").ArtifactRecord>;
+    getIndexingState: (ownerId: string, artifactId: string) => Promise<import("./types").ArtifactIndexingState | null>;
+    getRevision: (ownerId: string, artifactId: string, revision: number) => Promise<Readonly<import("./types").ArtifactRecord<unknown>>>;
     list: (ownerId: string, query?: import("./types").ArtifactListQuery) => Promise<import("./types").ArtifactRecord[]>;
-    publish: (ownerId: string, artifactId: string) => Promise<import("./types").ArtifactRecord>;
+    listEvents: (query?: import("./types").ArtifactEventQuery) => Promise<import("./types").ArtifactEvent[]>;
+    listRevisions: (ownerId: string, artifactId: string) => Promise<Readonly<import("./types").ArtifactRecord<unknown>>[]>;
+    markEventProcessed: (eventId: string, processedAt?: string) => Promise<boolean>;
+    markIndexing: (ownerId: string, artifactId: string, input: {
+        documentIds?: string[];
+        error?: string;
+        revision: number;
+        status: import("./types").ArtifactIndexingStatus;
+    }) => Promise<import("./types").ArtifactIndexingState>;
+    publish: (ownerId: string, artifactId: string, input?: import("./types").ArtifactPublishInput) => Promise<import("./types").ArtifactRecord>;
+    readAsset: (ownerId: string, artifactId: string, assetId: string) => Promise<{
+        asset: import("./types").ArtifactAssetReference;
+        data: Uint8Array<ArrayBufferLike>;
+    }>;
+    restore: (ownerId: string, artifactId: string, revision: number, expectedRevision?: number) => Promise<import("./types").ArtifactRecord>;
     unpublish: (ownerId: string, artifactId: string) => Promise<import("./types").ArtifactRecord>;
     update: (ownerId: string, artifactId: string, input: import("./types").ArtifactUpdateInput) => Promise<import("./types").ArtifactRecord>;
 }>;

package/dist/src/rag.d.ts

@@ -0,0 +1,46 @@
+import type { RAGDocumentUploadInput } from "@absolutejs/rag";
+import type { ArtifactAssetReference, ArtifactRecord } from "./types";
+export type ArtifactRAGAssetReader = {
+    read(reference: ArtifactAssetReference, context: {
+        artifact: ArtifactRecord;
+    }): Promise<Uint8Array>;
+};
+export type ArtifactRAGUploadOptions = {
+    includeStructuredContent?: boolean;
+};
+export type ArtifactRAGIndexTarget = {
+    index(uploads: RAGDocumentUploadInput[], context: {
+        artifact: ArtifactRecord;
+    }): Promise<{
+        documentIds: string[];
+    }>;
+    remove?(documentIds: string[], context: {
+        artifact: ArtifactRecord;
+    }): Promise<void>;
+};
+export type ArtifactRAGIndexStateWriter = {
+    getIndexingState(ownerId: string, artifactId: string): Promise<{
+        documentIds: string[];
+    } | null>;
+    markIndexing(ownerId: string, artifactId: string, input: {
+        documentIds?: string[];
+        error?: string;
+        revision: number;
+        status: "failed" | "indexed" | "pending" | "stale";
+    }): Promise<unknown>;
+};
+/**
+ * Resolve an artifact revision into upload inputs accepted by @absolutejs/rag.
+ * Storage URIs remain opaque; only the supplied reader is allowed to access bytes.
+ */
+export declare const artifactToRAGUploads: (artifact: ArtifactRecord, reader: ArtifactRAGAssetReader, options?: ArtifactRAGUploadOptions) => Promise<RAGDocumentUploadInput[]>;
+export declare const createArtifactRAGIndexCoordinator: (options: {
+    reader: ArtifactRAGAssetReader;
+    service: ArtifactRAGIndexStateWriter;
+    target: ArtifactRAGIndexTarget;
+}) => {
+    index: (artifact: ArtifactRecord) => Promise<{
+        documentIds: string[];
+    }>;
+};
+export type ArtifactRAGIndexCoordinator = ReturnType<typeof createArtifactRAGIndexCoordinator>;

package/dist/src/registry.d.ts

@@ -1,6 +1,12 @@
 import type { Static, TSchema } from "@sinclair/typebox";
 import { type ArtifactCapability } from "./types";
+export type ArtifactAssetPolicy = {
+    /** Exact media types or wildcards such as image/* and application/*. */
+    acceptedMediaTypes?: string[];
+    maxCount?: number;
+};
 export type ArtifactKindDefinition<TContent extends TSchema = TSchema> = {
+    assets?: ArtifactAssetPolicy;
     capabilities?: ArtifactCapability[];
     content: TContent;
     description?: string;

package/dist/src/service.d.ts

@@ -1,9 +1,11 @@
 import type { ArtifactKindDefinitions, ArtifactRegistry } from "./registry";
-import type { ArtifactStore } from "./store";
-import { type ArtifactCreateInput, type ArtifactListQuery, type ArtifactRecord, type ArtifactUpdateInput } from "./types";
+import type { ArtifactAssetStore, ArtifactStore } from "./store";
+import { type ArtifactAssetReference, type ArtifactAssetWriteInput, type ArtifactBundleCreateInput, type ArtifactCreateInput, type ArtifactEvent, type ArtifactEventQuery, type ArtifactGarbageCollectionResult, type ArtifactIndexingState, type ArtifactIndexingStatus, type ArtifactListQuery, type ArtifactPublishInput, type ArtifactRecord, type ArtifactUpdateInput } from "./types";
 export type ArtifactPublisher = {
     publish(artifact: ArtifactRecord, options: {
         idempotencyKey: string;
+        mode: "live" | "pinned";
+        revision: number;
     }): Promise<{
         id: string;
         url: string;
@@ -13,7 +15,9 @@ export type ArtifactPublisher = {
     }): Promise<void>;
 };
 export type ArtifactServiceOptions<TDefinitions extends ArtifactKindDefinitions = ArtifactKindDefinitions> = {
+    assetStore?: ArtifactAssetStore;
     clock?: () => Date;
+    eventIdFactory?: () => string;
     idFactory?: () => string;
     publisher?: ArtifactPublisher;
     registry: ArtifactRegistry<TDefinitions>;
@@ -22,10 +26,34 @@ export type ArtifactServiceOptions<TDefinitions extends ArtifactKindDefinitions
 export type ArtifactService = ReturnType<typeof createArtifactService>;
 export declare const createArtifactService: <TDefinitions extends ArtifactKindDefinitions>(options: ArtifactServiceOptions<TDefinitions>) => {
     archive: (ownerId: string, artifactId: string) => Promise<ArtifactRecord>;
+    attach: (ownerId: string, artifactId: string, input: ArtifactAssetWriteInput, expectedRevision?: number) => Promise<ArtifactRecord>;
+    attachBundle: (ownerId: string, artifactId: string, inputs: ArtifactAssetWriteInput[], expectedRevision?: number) => Promise<ArtifactRecord>;
+    collectAssetGarbage: (input: {
+        dryRun?: boolean;
+        minimumAgeMs?: number;
+    }) => Promise<ArtifactGarbageCollectionResult>;
     create: (ownerId: string, input: ArtifactCreateInput) => Promise<ArtifactRecord>;
+    createBundle: (ownerId: string, input: ArtifactBundleCreateInput) => Promise<ArtifactRecord>;
+    detach: (ownerId: string, artifactId: string, assetId: string, expectedRevision?: number) => Promise<ArtifactRecord>;
     get: (ownerId: string, artifactId: string) => Promise<ArtifactRecord>;
+    getIndexingState: (ownerId: string, artifactId: string) => Promise<ArtifactIndexingState | null>;
+    getRevision: (ownerId: string, artifactId: string, revision: number) => Promise<Readonly<ArtifactRecord<unknown>>>;
     list: (ownerId: string, query?: ArtifactListQuery) => Promise<ArtifactRecord[]>;
-    publish: (ownerId: string, artifactId: string) => Promise<ArtifactRecord>;
+    listEvents: (query?: ArtifactEventQuery) => Promise<ArtifactEvent[]>;
+    listRevisions: (ownerId: string, artifactId: string) => Promise<Readonly<ArtifactRecord<unknown>>[]>;
+    markEventProcessed: (eventId: string, processedAt?: string) => Promise<boolean>;
+    markIndexing: (ownerId: string, artifactId: string, input: {
+        documentIds?: string[];
+        error?: string;
+        revision: number;
+        status: ArtifactIndexingStatus;
+    }) => Promise<ArtifactIndexingState>;
+    publish: (ownerId: string, artifactId: string, input?: ArtifactPublishInput) => Promise<ArtifactRecord>;
+    readAsset: (ownerId: string, artifactId: string, assetId: string) => Promise<{
+        asset: ArtifactAssetReference;
+        data: Uint8Array<ArrayBufferLike>;
+    }>;
+    restore: (ownerId: string, artifactId: string, revision: number, expectedRevision?: number) => Promise<ArtifactRecord>;
     unpublish: (ownerId: string, artifactId: string) => Promise<ArtifactRecord>;
     update: (ownerId: string, artifactId: string, input: ArtifactUpdateInput) => Promise<ArtifactRecord>;
 };

package/dist/src/standardKinds.d.ts

@@ -0,0 +1,157 @@
+export declare const standardArtifactDefinitions: {
+    archive: {
+        assets: {
+            acceptedMediaTypes: string[];
+            maxCount: number;
+        };
+        capabilities: ("attach" | "archive" | "edit" | "export" | "preview" | "refine")[];
+        content: import("@sinclair/typebox").TObject<{
+            description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            instructions: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            summary: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        }>;
+        label: string;
+        schemaVersion: number;
+    };
+    audio: {
+        assets: {
+            acceptedMediaTypes: string[];
+            maxCount: number;
+        };
+        capabilities: ("attach" | "archive" | "edit" | "export" | "preview" | "refine")[];
+        content: import("@sinclair/typebox").TObject<{
+            description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            instructions: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            summary: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        }>;
+        label: string;
+        schemaVersion: number;
+    };
+    code: {
+        assets: {
+            acceptedMediaTypes: string[];
+            maxCount: number;
+        };
+        capabilities: ("attach" | "archive" | "edit" | "export" | "preview" | "refine")[];
+        content: import("@sinclair/typebox").TObject<{
+            description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            instructions: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            summary: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        }>;
+        label: string;
+        schemaVersion: number;
+    };
+    dataset: {
+        assets: {
+            acceptedMediaTypes: string[];
+            maxCount: number;
+        };
+        capabilities: ("attach" | "archive" | "edit" | "export" | "preview" | "refine")[];
+        content: import("@sinclair/typebox").TObject<{
+            description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            instructions: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            summary: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        }>;
+        label: string;
+        schemaVersion: number;
+    };
+    document: {
+        assets: {
+            acceptedMediaTypes: string[];
+            maxCount: number;
+        };
+        capabilities: ("attach" | "archive" | "edit" | "export" | "preview" | "refine")[];
+        content: import("@sinclair/typebox").TObject<{
+            description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            instructions: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            summary: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        }>;
+        label: string;
+        schemaVersion: number;
+    };
+    email: {
+        assets: {
+            acceptedMediaTypes: string[];
+            maxCount: number;
+        };
+        capabilities: ("attach" | "archive" | "edit" | "export" | "preview" | "refine")[];
+        content: import("@sinclair/typebox").TObject<{
+            description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            instructions: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            summary: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        }>;
+        label: string;
+        schemaVersion: number;
+    };
+    file: {
+        assets: {
+            acceptedMediaTypes: string[];
+            maxCount: number;
+        };
+        capabilities: ("attach" | "archive" | "edit" | "export" | "preview" | "refine")[];
+        content: import("@sinclair/typebox").TObject<{
+            description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            instructions: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            summary: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        }>;
+        label: string;
+        schemaVersion: number;
+    };
+    image: {
+        assets: {
+            acceptedMediaTypes: string[];
+            maxCount: number;
+        };
+        capabilities: ("attach" | "archive" | "edit" | "export" | "preview" | "refine")[];
+        content: import("@sinclair/typebox").TObject<{
+            description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            instructions: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            summary: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        }>;
+        label: string;
+        schemaVersion: number;
+    };
+    presentation: {
+        assets: {
+            acceptedMediaTypes: string[];
+            maxCount: number;
+        };
+        capabilities: ("attach" | "archive" | "edit" | "export" | "preview" | "refine")[];
+        content: import("@sinclair/typebox").TObject<{
+            description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            instructions: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            summary: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        }>;
+        label: string;
+        schemaVersion: number;
+    };
+    spreadsheet: {
+        assets: {
+            acceptedMediaTypes: string[];
+            maxCount: number;
+        };
+        capabilities: ("attach" | "archive" | "edit" | "export" | "preview" | "refine")[];
+        content: import("@sinclair/typebox").TObject<{
+            description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            instructions: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            summary: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        }>;
+        label: string;
+        schemaVersion: number;
+    };
+    video: {
+        assets: {
+            acceptedMediaTypes: string[];
+            maxCount: number;
+        };
+        capabilities: ("attach" | "archive" | "edit" | "export" | "preview" | "refine")[];
+        content: import("@sinclair/typebox").TObject<{
+            description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            instructions: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            summary: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        }>;
+        label: string;
+        schemaVersion: number;
+    };
+};
+export declare const STANDARD_ARTIFACT_KIND_NAMES: Array<keyof typeof standardArtifactDefinitions>;

package/dist/src/store.d.ts

@@ -1,8 +1,38 @@
-import type { ArtifactListQuery, ArtifactRecord } from "./types";
+import type { ArtifactAssetReference, ArtifactAssetWriteInput, ArtifactEvent, ArtifactEventQuery, ArtifactIndexingState, ArtifactListQuery, ArtifactRecord, ArtifactRevision, ArtifactRetentionCandidate } from "./types";
+export type ArtifactAssetTransaction = {
+    commit(): Promise<void>;
+    references: ArtifactAssetReference[];
+    rollback(): Promise<void>;
+};
+export type ArtifactAssetStore = {
+    delete(reference: ArtifactAssetReference): Promise<void>;
+    listCandidates(): Promise<ArtifactRetentionCandidate[]>;
+    read(reference: ArtifactAssetReference, context: {
+        artifact: ArtifactRecord;
+    }): Promise<Uint8Array>;
+    write(input: ArtifactAssetWriteInput, context: {
+        artifact: ArtifactRecord;
+        idempotencyKey: string;
+    }): Promise<ArtifactAssetReference>;
+    stage?(inputs: ArtifactAssetWriteInput[], context: {
+        artifact: ArtifactRecord;
+        idempotencyKey: string;
+    }): Promise<ArtifactAssetTransaction>;
+};
 export type ArtifactStore = {
-    create(record: ArtifactRecord): Promise<void>;
+    /** Persist the current record and its first immutable revision atomically. */
+    create(record: ArtifactRecord, events?: ArtifactEvent[]): Promise<void>;
+    getIndexingState(ownerId: string, artifactId: string): Promise<ArtifactIndexingState | null>;
     get(ownerId: string, artifactId: string): Promise<ArtifactRecord | null>;
+    getRevision(ownerId: string, artifactId: string, revision: number): Promise<ArtifactRevision | null>;
     list(ownerId: string, query?: ArtifactListQuery): Promise<ArtifactRecord[]>;
-    save(record: ArtifactRecord, expectedRevision: number): Promise<boolean>;
+    listRevisions(ownerId: string, artifactId: string): Promise<ArtifactRevision[]>;
+    listEvents(query?: ArtifactEventQuery): Promise<ArtifactEvent[]>;
+    listReferencedAssetIds(): Promise<string[]>;
+    markEventProcessed(eventId: string, processedAt: string): Promise<boolean>;
+    putIndexingState(ownerId: string, state: ArtifactIndexingState, events?: ArtifactEvent[]): Promise<void>;
+    /** Compare, replace current state, and append its revision atomically. */
+    save(record: ArtifactRecord, expectedRevision: number, events?: ArtifactEvent[]): Promise<boolean>;
 };
+export declare const createMemoryArtifactAssetStore: () => ArtifactAssetStore;
 export declare const createMemoryArtifactStore: (initial?: ArtifactRecord[]) => ArtifactStore;