@absolutejs/artifacts 0.2.0 → 0.3.0

package/dist/manifest.js

@@ -1,5 +1,5 @@
 // @bun
-// ../manifest/dist/index.js
+// node_modules/@absolutejs/manifest/dist/index.js
 import { Type } from "typebox";
 import { Value } from "typebox/value";
 import { Type as Type2 } from "typebox";

package/dist/rag.js

@@ -1,6 +1,15 @@
 // @bun
 // src/rag.ts
 import { Buffer } from "buffer";
+
+class ArtifactRAGPartialIndexError extends Error {
+  receipt;
+  constructor(receipt) {
+    super(`Artifact ${receipt.artifactId} indexed ${receipt.indexedUploads}/${receipt.totalUploads} uploads; ${receipt.failures.length} failed`);
+    this.name = "ArtifactRAGPartialIndexError";
+    this.receipt = receipt;
+  }
+}
 var artifactMetadata = (artifact) => ({
   artifactId: artifact.id,
   artifactKind: artifact.kind,
@@ -49,6 +58,58 @@ var createArtifactRAGIndexCoordinator = (options) => ({
     });
     try {
       const uploads = await artifactToRAGUploads(artifact, options.reader);
+      if (options.failureMode === "isolate_uploads") {
+        const documentIds = [];
+        const failures = [];
+        let indexedUploads = 0;
+        for (const upload of uploads) {
+          try {
+            const indexed2 = await options.target.index([upload], { artifact });
+            documentIds.push(...indexed2.documentIds);
+            indexedUploads += 1;
+          } catch (error) {
+            failures.push({
+              contentType: upload.contentType ?? "application/octet-stream",
+              error: error instanceof Error ? error.message : String(error),
+              name: upload.name ?? "unnamed upload",
+              source: upload.source ?? `artifact:${artifact.id}`
+            });
+          }
+        }
+        const receipt = {
+          artifactId: artifact.id,
+          documentIds,
+          failures,
+          indexedUploads,
+          revision: artifact.revision,
+          status: failures.length === 0 ? "indexed" : indexedUploads > 0 ? "partial" : "failed",
+          totalUploads: uploads.length
+        };
+        if (failures.length > 0) {
+          await options.service.markIndexing(artifact.ownerId, artifact.id, {
+            documentIds: [
+              ...new Set([...previous?.documentIds ?? [], ...documentIds])
+            ],
+            error: JSON.stringify({ failures, receipt }),
+            revision: artifact.revision,
+            status: receipt.status
+          });
+          throw new ArtifactRAGPartialIndexError(receipt);
+        }
+        if (previous?.documentIds.length && options.target.remove) {
+          const currentIds = new Set(documentIds);
+          const obsoleteIds = previous.documentIds.filter((documentId) => !currentIds.has(documentId));
+          if (obsoleteIds.length) {
+            await options.target.remove(obsoleteIds, { artifact });
+          }
+        }
+        await options.service.markIndexing(artifact.ownerId, artifact.id, {
+          documentIds,
+          revision: artifact.revision,
+          status: "indexed"
+        });
+        return receipt;
+      }
       const indexed = await options.target.index(uploads, { artifact });
       if (previous?.documentIds.length && options.target.remove) {
         const currentIds = new Set(indexed.documentIds);
@@ -62,8 +123,18 @@ var createArtifactRAGIndexCoordinator = (options) => ({
         revision: artifact.revision,
         status: "indexed"
       });
-      return indexed;
+      return {
+        artifactId: artifact.id,
+        documentIds: indexed.documentIds,
+        failures: [],
+        indexedUploads: uploads.length,
+        revision: artifact.revision,
+        status: "indexed",
+        totalUploads: uploads.length
+      };
     } catch (error) {
+      if (error instanceof ArtifactRAGPartialIndexError)
+        throw error;
       await options.service.markIndexing(artifact.ownerId, artifact.id, {
         documentIds: previous?.documentIds,
         error: error instanceof Error ? error.message : String(error),
@@ -75,6 +146,7 @@ var createArtifactRAGIndexCoordinator = (options) => ({
   }
 });
 export {
-  createArtifactRAGIndexCoordinator,
-  artifactToRAGUploads
+  ArtifactRAGPartialIndexError,
+  artifactToRAGUploads,
+  createArtifactRAGIndexCoordinator
 };

package/dist/src/generators.d.ts

@@ -1,4 +1,4 @@
-import type { ArtifactAssetWriteInput, ArtifactBundleCreateInput, ArtifactProvenance, ArtifactRecord, JsonObject, JsonValue } from "./types";
+import type { ArtifactAssetWriteInput, ArtifactBatchCompletionReceipt, ArtifactBatchCreateInput, ArtifactBatchValidator, ArtifactBundleCreateInput, ArtifactEvidenceReference, ArtifactProvenance, ArtifactRecord, JsonObject, JsonValue } from "./types";
 export type ArtifactGenerationInput = {
     createdBy: string;
     input?: JsonObject;
@@ -22,12 +22,35 @@ export type ArtifactGenerator = {
     generate(input: ArtifactGenerationInput, context: ArtifactGenerationContext): Promise<ArtifactGenerationResult>;
     kind: string;
     name: string;
+    validate?(result: ArtifactGenerationResult, input: ArtifactGenerationInput, context: ArtifactGenerationContext): ArtifactGenerationValidationIssue[] | Promise<ArtifactGenerationValidationIssue[]>;
+};
+export type ArtifactGenerationValidationIssue = {
+    code: string;
+    message: string;
+    path?: string;
 };
 export type ArtifactBundleCreator = {
     createBundle(ownerId: string, input: ArtifactBundleCreateInput): Promise<ArtifactRecord>;
 };
+export type ArtifactBatchGeneratorService = ArtifactBundleCreator & {
+    stageBatch(ownerId: string, input: ArtifactBatchCreateInput, options?: {
+        validators?: ArtifactBatchValidator[];
+    }): Promise<{
+        commit(): Promise<ArtifactBatchCompletionReceipt>;
+    }>;
+};
+export type ArtifactBatchGenerationItem = Omit<ArtifactGenerationInput, "ownerId"> & {
+    evidence?: ArtifactEvidenceReference[];
+    key: string;
+};
+export type ArtifactBatchGenerationInput = Omit<ArtifactBatchCreateInput, "items"> & {
+    items: ArtifactBatchGenerationItem[];
+    ownerId: string;
+    validators?: ArtifactBatchValidator[];
+};
 export declare const createArtifactGeneratorRegistry: (initial?: ArtifactGenerator[]) => {
     generate: (service: ArtifactBundleCreator, input: ArtifactGenerationInput) => Promise<ArtifactRecord>;
+    generateBatch: (service: ArtifactBatchGeneratorService, input: ArtifactBatchGenerationInput) => Promise<ArtifactBatchCompletionReceipt>;
     kinds: () => string[];
     register: (generator: ArtifactGenerator) => void;
 };

package/dist/src/index.d.ts

@@ -7,10 +7,11 @@
  * 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 { createArtifactGeneratorRegistry, type ArtifactBundleCreator, type ArtifactGenerationContext, type ArtifactGenerationInput, type ArtifactGenerationResult, type ArtifactGenerator, type ArtifactGeneratorRegistry, type ArtifactBatchGenerationInput, type ArtifactBatchGenerationItem, type ArtifactBatchGeneratorService, type ArtifactGenerationValidationIssue, } from "./generators";
+export { validateGeneratedArtifactFormats } from "./validation";
 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, createMemoryArtifactAssetStore, type ArtifactAssetStore, type ArtifactAssetTransaction, type ArtifactStore, } from "./store";
 export { createArtifactTools, type ArtifactToolDefinition, type ArtifactToolMap, type ArtifactToolOptions, } from "./tools";
-export { ARTIFACT_STATUSES, ARTIFACT_EVENT_TYPES, ArtifactError, isJsonValue, 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, type JsonObject, type JsonPrimitive, type JsonValue, } from "./types";
+export { ARTIFACT_STATUSES, ARTIFACT_EVENT_TYPES, ArtifactError, isJsonValue, type ArtifactAssetReference, type ArtifactAssetRole, type ArtifactAssetWriteInput, type ArtifactBatchCommitMode, type ArtifactBatchCompletionReceipt, type ArtifactBatchCreateInput, type ArtifactBatchItemInput, type ArtifactBatchReceiptItem, type ArtifactBatchValidationIssue, type ArtifactBatchValidationResult, type ArtifactBatchValidator, type ArtifactBundleCreateInput, type ArtifactCapability, type ArtifactCreateInput, type ArtifactErrorCode, type ArtifactEvent, type ArtifactEventQuery, type ArtifactEventType, type ArtifactEvidenceReference, 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, type JsonObject, type JsonPrimitive, type JsonValue, type StagedArtifactBatch, } from "./types";

package/dist/src/manifest.d.ts

@@ -9,6 +9,9 @@ export declare const manifest: Omit<import("@absolutejs/manifest").PackageManife
     }) => 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>;
+    stageBatch: (ownerId: string, input: import("./types").ArtifactBatchCreateInput, stageOptions?: {
+        validators?: import("./types").ArtifactBatchValidator[];
+    }) => Promise<import("./types").StagedArtifactBatch>;
     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>;
@@ -44,6 +47,9 @@ export declare const manifest: Omit<import("@absolutejs/manifest").PackageManife
         }) => 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>;
+        stageBatch: (ownerId: string, input: import("./types").ArtifactBatchCreateInput, stageOptions?: {
+            validators?: import("./types").ArtifactBatchValidator[];
+        }) => Promise<import("./types").StagedArtifactBatch>;
         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>;
@@ -80,6 +86,9 @@ export declare const manifest: Omit<import("@absolutejs/manifest").PackageManife
         }) => 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>;
+        stageBatch: (ownerId: string, input: import("./types").ArtifactBatchCreateInput, stageOptions?: {
+            validators?: import("./types").ArtifactBatchValidator[];
+        }) => Promise<import("./types").StagedArtifactBatch>;
         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>;

package/dist/src/rag.d.ts

@@ -26,21 +26,39 @@ export type ArtifactRAGIndexStateWriter = {
         documentIds?: string[];
         error?: string;
         revision: number;
-        status: "failed" | "indexed" | "pending" | "stale";
+        status: "failed" | "indexed" | "partial" | "pending" | "stale";
     }): Promise<unknown>;
 };
+export type ArtifactRAGIndexFailure = {
+    contentType: string;
+    error: string;
+    name: string;
+    source: string;
+};
+export type ArtifactRAGIndexReceipt = {
+    artifactId: string;
+    documentIds: string[];
+    failures: ArtifactRAGIndexFailure[];
+    indexedUploads: number;
+    revision: number;
+    status: "failed" | "indexed" | "partial";
+    totalUploads: number;
+};
+export declare class ArtifactRAGPartialIndexError extends Error {
+    readonly receipt: ArtifactRAGIndexReceipt;
+    constructor(receipt: ArtifactRAGIndexReceipt);
+}
 /**
  * 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: {
+    failureMode?: "fail_fast" | "isolate_uploads";
     reader: ArtifactRAGAssetReader;
     service: ArtifactRAGIndexStateWriter;
     target: ArtifactRAGIndexTarget;
 }) => {
-    index: (artifact: ArtifactRecord) => Promise<{
-        documentIds: string[];
-    }>;
+    index: (artifact: ArtifactRecord) => Promise<ArtifactRAGIndexReceipt>;
 };
 export type ArtifactRAGIndexCoordinator = ReturnType<typeof createArtifactRAGIndexCoordinator>;

package/dist/src/service.d.ts

@@ -1,6 +1,6 @@
 import type { ArtifactKindDefinitions, ArtifactRegistry } from "./registry";
 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";
+import { type ArtifactAssetReference, type ArtifactAssetWriteInput, type ArtifactBatchCreateInput, type ArtifactBatchValidator, type ArtifactBundleCreateInput, type ArtifactCreateInput, type ArtifactEvent, type ArtifactEventQuery, type ArtifactGarbageCollectionResult, type ArtifactIndexingState, type ArtifactIndexingStatus, type ArtifactListQuery, type ArtifactPublishInput, type ArtifactRecord, type ArtifactUpdateInput, type StagedArtifactBatch } from "./types";
 export type ArtifactPublisher = {
     publish(artifact: ArtifactRecord, options: {
         idempotencyKey: string;
@@ -16,6 +16,7 @@ export type ArtifactPublisher = {
 };
 export type ArtifactServiceOptions<TDefinitions extends ArtifactKindDefinitions = ArtifactKindDefinitions> = {
     assetStore?: ArtifactAssetStore;
+    batchIdFactory?: () => string;
     clock?: () => Date;
     eventIdFactory?: () => string;
     idFactory?: () => string;
@@ -34,6 +35,9 @@ export declare const createArtifactService: <TDefinitions extends ArtifactKindDe
     }) => Promise<ArtifactGarbageCollectionResult>;
     create: (ownerId: string, input: ArtifactCreateInput) => Promise<ArtifactRecord>;
     createBundle: (ownerId: string, input: ArtifactBundleCreateInput) => Promise<ArtifactRecord>;
+    stageBatch: (ownerId: string, input: ArtifactBatchCreateInput, stageOptions?: {
+        validators?: ArtifactBatchValidator[];
+    }) => Promise<StagedArtifactBatch>;
     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>;

package/dist/src/store.d.ts

@@ -22,6 +22,11 @@ export type ArtifactAssetStore = {
 export type ArtifactStore = {
     /** Persist the current record and its first immutable revision atomically. */
     create(record: ArtifactRecord, events?: ArtifactEvent[]): Promise<void>;
+    /** Persist multiple records, first revisions, and events in one transaction. */
+    createBatch?(entries: Array<{
+        events?: ArtifactEvent[];
+        record: ArtifactRecord;
+    }>): 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>;

package/dist/src/types.d.ts

@@ -8,12 +8,20 @@ export declare function isJsonValue(value: unknown): value is JsonValue;
 export type ArtifactStatus = (typeof ARTIFACT_STATUSES)[number];
 export type ArtifactCapability = "attach" | "archive" | "edit" | "export" | "preview" | "publish" | "refine";
 export type ArtifactProvenance = {
+    evidence?: ArtifactEvidenceReference[];
     lineage?: ArtifactLineageReference[];
     model?: string;
     sourceIds?: string[];
     tool?: string;
     traceId?: string;
 };
+export type ArtifactEvidenceReference = {
+    capturedAt?: string;
+    excerpt?: string;
+    metadata?: JsonObject;
+    sourceId?: string;
+    sourceUrl?: string;
+};
 export type ArtifactLineageRelation = "derived_from" | "generated_from" | "references" | "replaces";
 export type ArtifactLineageReference = {
     artifactId?: string;
@@ -86,7 +94,7 @@ export type ArtifactEventQuery = {
     processed?: boolean;
     type?: ArtifactEventType;
 };
-export type ArtifactIndexingStatus = "failed" | "indexed" | "pending" | "stale";
+export type ArtifactIndexingStatus = "failed" | "indexed" | "partial" | "pending" | "stale";
 export type ArtifactIndexingState = {
     artifactId: string;
     documentIds: string[];
@@ -122,6 +130,78 @@ export type ArtifactUpdateInput = {
 export type ArtifactBundleCreateInput = Omit<ArtifactCreateInput, "assets"> & {
     assets?: ArtifactAssetWriteInput[];
 };
+export type ArtifactBatchItemInput = {
+    artifact: ArtifactBundleCreateInput;
+    evidence?: ArtifactEvidenceReference[];
+    /** Stable caller-defined key used to reconcile a receipt with requested output. */
+    key: string;
+};
+export type ArtifactBatchCommitMode = "archive_on_failure" | "require_atomic";
+export type ArtifactBatchCreateInput = {
+    bundleId?: string;
+    commitMode?: ArtifactBatchCommitMode;
+    evidence?: ArtifactEvidenceReference[];
+    items: ArtifactBatchItemInput[];
+    metadata?: JsonObject;
+    provenance?: ArtifactProvenance;
+};
+export type ArtifactBatchValidationIssue = {
+    code: string;
+    itemKey?: string;
+    message: string;
+    path?: string;
+};
+export type ArtifactBatchValidationResult = {
+    issues?: never;
+    valid: true;
+} | {
+    issues: ArtifactBatchValidationIssue[];
+    valid: false;
+};
+export type ArtifactBatchReceiptItem = {
+    artifactId: string;
+    archived?: boolean;
+    key: string;
+    kind: string;
+    revision: number;
+    title: string;
+};
+export type ArtifactBatchCompletionReceipt = {
+    archivedArtifactIds: string[];
+    atomic: boolean;
+    bundleId: string;
+    completedAt: string;
+    error?: string;
+    items: ArtifactBatchReceiptItem[];
+    ownerId: string;
+    stagedAt: string;
+    status: "committed" | "partial_failure" | "rolled_back";
+    validation: ArtifactBatchValidationResult;
+};
+export type ArtifactBatchValidator = (context: {
+    bundleId: string;
+    evidence: ArtifactEvidenceReference[];
+    items: ReadonlyArray<{
+        evidence: ArtifactEvidenceReference[];
+        key: string;
+        record: Readonly<ArtifactRecord>;
+    }>;
+    ownerId: string;
+}) => ArtifactBatchValidationIssue[] | Promise<ArtifactBatchValidationIssue[]>;
+export type StagedArtifactBatch = {
+    bundleId: string;
+    commit(): Promise<ArtifactBatchCompletionReceipt>;
+    evidence: ArtifactEvidenceReference[];
+    items: ReadonlyArray<{
+        evidence: ArtifactEvidenceReference[];
+        key: string;
+        record: Readonly<ArtifactRecord>;
+    }>;
+    ownerId: string;
+    rollback(reason?: string): Promise<ArtifactBatchCompletionReceipt>;
+    stagedAt: string;
+    validation: ArtifactBatchValidationResult;
+};
 export type ArtifactPublishInput = {
     mode?: "live" | "pinned";
 };
@@ -133,7 +213,7 @@ export type ArtifactGarbageCollectionResult = {
     deleted: ArtifactAssetReference[];
     retained: ArtifactAssetReference[];
 };
-export type ArtifactErrorCode = "asset_store_unavailable" | "asset_transaction_unavailable" | "conflict" | "generator_unavailable" | "invalid_content" | "not_found" | "publisher_unavailable" | "renderer_unavailable" | "unsupported_capability" | "unknown_kind";
+export type ArtifactErrorCode = "asset_store_unavailable" | "asset_transaction_unavailable" | "atomic_batch_unavailable" | "batch_validation_failed" | "conflict" | "generator_unavailable" | "invalid_content" | "not_found" | "publisher_unavailable" | "renderer_unavailable" | "unsupported_capability" | "unknown_kind";
 export declare class ArtifactError extends Error {
     readonly code: ArtifactErrorCode;
     constructor(code: ArtifactErrorCode, message: string);

package/dist/src/validation.d.ts

@@ -0,0 +1,3 @@
+import type { ArtifactGenerationResult, ArtifactGenerationValidationIssue } from "./generators";
+/** Validate common generated download formats before an artifact is committed. */
+export declare const validateGeneratedArtifactFormats: (result: ArtifactGenerationResult) => ArtifactGenerationValidationIssue[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@absolutejs/artifacts",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Typed, versioned artifacts for AI products — schemas, lifecycle, storage, rendering, publishing, revisions, and agent tools without prescribing a database or host.",
   "author": "Alex Kahn",
   "license": "BUSL-1.1",
@@ -60,6 +60,7 @@
     "@absolutejs/manifest": "^0.10.0",
     "@sinclair/typebox": "^0.34.0",
     "drizzle-typebox": "1.0.0-beta.14-a36c63d",
+    "fflate": "^0.8.2",
     "typebox": "^1.3.16"
   },
   "peerDependencies": {