@jolly-pixel/asset-server 1.0.0

package/dist/createAssetBackend.d.ts

@@ -0,0 +1,79 @@
+import type * as EventStore from "@jolly-pixel/event-store";
+import type { Server } from "@jolly-pixel/network";
+import type { AssetSource } from "@jolly-pixel/asset-source";
+import type { AssetEventDataMap } from "./events/AssetEvents.ts";
+import { CatalogIdentitySidecar } from "./catalog/CatalogIdentitySidecar.ts";
+import { AssetKindRegistry } from "./kinds/AssetKindRegistry.ts";
+import type { AssetKindHandler, SnapshotPolicy } from "./kinds/AssetKindHandler.ts";
+import { ProjectionState } from "./sync/ProjectionState.ts";
+import { AssetProjector } from "./sync/AssetProjector.ts";
+import { AssetStateStore } from "./sync/AssetStateStore.ts";
+import { AssetWriter } from "./sync/AssetWriter.ts";
+import { SnapshotScheduler } from "./sync/SnapshotScheduler.ts";
+import { Reconciler } from "./sync/Reconciler.ts";
+import { ReconciliationWatcher } from "./sync/ReconciliationWatcher.ts";
+import { CatalogProjection } from "./catalog/CatalogProjection.ts";
+import { CatalogExtension } from "./catalog/CatalogExtension.ts";
+import { type Logger } from "./logger.ts";
+export interface AssetBackendOptions {
+    source: AssetSource;
+    eventStore: EventStore.TypedEventStore<AssetEventDataMap>;
+    /**
+     * Kind handlers. The built-in `binary` fallback is always present and
+     * claims whatever these do not.
+     */
+    handlers?: AssetKindHandler[];
+    /**
+     * Default snapshot cadence, overridable per kind.
+     */
+    snapshot?: SnapshotPolicy;
+    /**
+     * Reconcile the physical store on startup.
+     * @default true
+     */
+    reconcileOnStart?: boolean;
+    /**
+     * Watch the source for external changes, when it supports it.
+     * @default true
+     */
+    watch?: boolean;
+    /**
+     * Quiet period, in milliseconds, before filesystem notifications become
+     * one reconciliation pass.
+     */
+    reconcileDebounce?: number;
+    logger?: Logger;
+}
+/**
+ * Internal stages exposed to tests, tooling, and hosts.
+ *
+ * They stay outside `AssetBackend` because their shapes are not public API.
+ */
+export interface AssetBackendInternals {
+    readonly identity: CatalogIdentitySidecar;
+    readonly state: ProjectionState;
+    readonly projector: AssetProjector;
+    readonly states: AssetStateStore;
+    readonly scheduler: SnapshotScheduler;
+    readonly reconciler: Reconciler;
+    readonly watcher: ReconciliationWatcher;
+    readonly catalogExtension: CatalogExtension;
+}
+export interface AssetBackend extends AsyncDisposable {
+    readonly source: AssetSource;
+    readonly eventStore: EventStore.TypedEventStore<AssetEventDataMap>;
+    readonly kinds: AssetKindRegistry;
+    readonly writer: AssetWriter;
+    readonly catalog: CatalogProjection;
+    readonly internals: AssetBackendInternals;
+    flush(assetId?: string): Promise<void>;
+    attach(server: Server, options?: {
+        graceMs?: number;
+    }): () => void;
+    close(): Promise<void>;
+}
+/**
+ * Assembles the asset backend and starts projections in dependency order.
+ */
+export declare function createAssetBackend(options: AssetBackendOptions): Promise<AssetBackend>;
+//# sourceMappingURL=createAssetBackend.d.ts.map

package/dist/createAssetBackend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createAssetBackend.d.ts","sourceRoot":"","sources":["../src/createAssetBackend.ts"],"names":[],"mappings":"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"}

package/dist/createAssetBackend.js

@@ -0,0 +1,146 @@
+// Import Internal Dependencies
+import { STATE_GITIGNORE_CONTENT, STATE_GITIGNORE_PATH } from "./constants.js";
+import { CatalogIdentitySidecar } from "./catalog/CatalogIdentitySidecar.js";
+import { AssetKindRegistry } from "./kinds/AssetKindRegistry.js";
+import { ProjectionState } from "./sync/ProjectionState.js";
+import { AssetProjector } from "./sync/AssetProjector.js";
+import { AssetStateStore } from "./sync/AssetStateStore.js";
+import { AssetWriter } from "./sync/AssetWriter.js";
+import { SnapshotScheduler } from "./sync/SnapshotScheduler.js";
+import { Reconciler } from "./sync/Reconciler.js";
+import { ReconciliationWatcher } from "./sync/ReconciliationWatcher.js";
+import { CatalogProjection } from "./catalog/CatalogProjection.js";
+import { CatalogExtension } from "./catalog/CatalogExtension.js";
+import { registerAssetRooms } from "./rooms/registerAssetRooms.js";
+import { silentLogger } from "./logger.js";
+/**
+ * Assembles the asset backend and starts projections in dependency order.
+ */
+export async function createAssetBackend(options) {
+    const { source, eventStore, handlers = [], snapshot, reconcileOnStart = true, watch = true, reconcileDebounce, logger = silentLogger() } = options;
+    const kinds = new AssetKindRegistry(handlers);
+    await ensureGitignore(source);
+    const state = await ProjectionState.load(source, logger);
+    const projector = new AssetProjector({
+        source,
+        eventStore,
+        state,
+        logger
+    });
+    projector.load();
+    projector.start();
+    const states = new AssetStateStore({
+        eventStore,
+        kinds
+    });
+    states.start();
+    const scheduler = new SnapshotScheduler({
+        eventStore,
+        states,
+        projector,
+        snapshot,
+        logger
+    });
+    scheduler.start();
+    const identity = await CatalogIdentitySidecar.load(source, logger);
+    const writer = new AssetWriter({
+        eventStore,
+        kinds,
+        projector,
+        identity,
+        source,
+        logger
+    });
+    const reconciler = new Reconciler({
+        source,
+        projector,
+        writer,
+        kinds,
+        logger
+    });
+    const watcher = new ReconciliationWatcher({
+        source,
+        reconciler,
+        debounce: reconcileDebounce,
+        logger
+    });
+    const catalog = new CatalogProjection({ eventStore });
+    if (reconcileOnStart) {
+        (await reconciler.reconcile()).orTee((error) => logger
+            .withMetadata({ reason: error.message })
+            .error("initial reconciliation failed"));
+        await projector.flush();
+    }
+    catalog.load();
+    catalog.start();
+    const catalogExtension = new CatalogExtension({
+        projection: catalog
+    });
+    if (watch) {
+        watcher.start();
+    }
+    const backend = {
+        source,
+        eventStore,
+        kinds,
+        writer,
+        catalog,
+        internals: {
+            identity,
+            state,
+            projector,
+            states,
+            scheduler,
+            reconciler,
+            watcher,
+            catalogExtension
+        },
+        async flush(assetId) {
+            await scheduler.flush(assetId);
+            await projector.flush(assetId);
+        },
+        attach(server, attachOptions = {}) {
+            server.register(catalogExtension);
+            return registerAssetRooms({
+                server,
+                kinds,
+                catalog,
+                states,
+                projector,
+                scheduler,
+                graceMs: attachOptions.graceMs,
+                logger
+            });
+        },
+        async close() {
+            await watcher.close();
+            await scheduler.close();
+            await projector.close();
+            states.close();
+            catalogExtension.dispose();
+            catalog.close();
+        },
+        async [Symbol.asyncDispose]() {
+            await backend.close();
+        }
+    };
+    return backend;
+}
+async function ensureGitignore(source) {
+    try {
+        await source.read(STATE_GITIGNORE_PATH);
+        return;
+    }
+    catch (error) {
+        if (!isNotFound(error)) {
+            return;
+        }
+    }
+    await source.write(STATE_GITIGNORE_PATH, new TextEncoder().encode(STATE_GITIGNORE_CONTENT));
+}
+function isNotFound(error) {
+    return typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === "ENOENT";
+}

package/dist/events/AssetEvents.d.ts

@@ -0,0 +1,54 @@
+import type * as EventStore from "@jolly-pixel/event-store";
+import { type Result } from "@openally/result";
+import { type Infer, type ValidationError } from "ata-validator";
+import { assetContentSchema, assetDeletedDataSchema, assetRenamedDataSchema, assetWriteDataSchema } from "./AssetEvents.schema.ts";
+export declare const ASSET_CREATED: "asset.created";
+export declare const ASSET_UPDATED: "asset.updated";
+export declare const ASSET_RENAMED: "asset.renamed";
+export declare const ASSET_DELETED: "asset.deleted";
+export type AssetEventType = typeof ASSET_CREATED | typeof ASSET_UPDATED | typeof ASSET_RENAMED | typeof ASSET_DELETED;
+export declare const ASSET_CHECKPOINT_EVENT_TYPES: readonly AssetEventType[];
+export type AssetContent = Infer<typeof assetContentSchema>;
+export type AssetInlineContent = Extract<AssetContent, {
+    type: "inline";
+}>;
+/**
+ * Shared payload for create and update events.
+ */
+export type AssetWriteData = Readonly<Omit<Infer<typeof assetWriteDataSchema>, "content"> & {
+    content: AssetInlineContent;
+}>;
+export type AssetCreatedData = AssetWriteData;
+export type AssetUpdatedData = AssetWriteData;
+export type AssetRenamedData = Readonly<Infer<typeof assetRenamedDataSchema>>;
+export type AssetDeletedData = Readonly<Infer<typeof assetDeletedDataSchema>>;
+export type AssetEventData = AssetWriteData | AssetRenamedData | AssetDeletedData;
+export type AssetEventDataMap = {
+    [ASSET_CREATED]: AssetCreatedData;
+    [ASSET_UPDATED]: AssetUpdatedData;
+    [ASSET_RENAMED]: AssetRenamedData;
+    [ASSET_DELETED]: AssetDeletedData;
+};
+export type AssetEvent = EventStore.TypedEvent<AssetEventDataMap>;
+/**
+ * Why an event on an asset stream did not yield an asset event.
+ *
+ * `foreign` means the event belongs to another domain and is none of our
+ * business. `malformed` and `unsupported` both mean an asset event we cannot
+ * project, and are worth reporting.
+ */
+export type AssetEventRejection = {
+    reason: "foreign";
+} | {
+    reason: "malformed";
+    errors: readonly ValidationError[];
+} | {
+    reason: "unsupported";
+    detail: string;
+};
+export declare function isAssetEventType(eventType: string): boolean;
+export declare function parseAssetEvent(event: EventStore.Event): Result<AssetEvent, AssetEventRejection>;
+export declare function describeRejection(rejection: AssetEventRejection): string;
+export declare function encodeContent(data: Uint8Array): AssetInlineContent;
+export declare function decodeContent(content: AssetInlineContent): Uint8Array;
+//# sourceMappingURL=AssetEvents.d.ts.map

package/dist/events/AssetEvents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AssetEvents.d.ts","sourceRoot":"","sources":["../../src/events/AssetEvents.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,KAAK,UAAU,MAAM,0BAA0B,CAAC;AAC5D,OAAO,EAGL,KAAK,MAAM,EACZ,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAEL,KAAK,KAAK,EACV,KAAK,eAAe,EACrB,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,kBAAkB,EAClB,sBAAsB,EACtB,sBAAsB,EACtB,oBAAoB,EACrB,MAAM,yBAAyB,CAAC;AAkBjC,eAAO,MAAM,aAAa,iBAA0C,CAAC;AACrE,eAAO,MAAM,aAAa,iBAA0C,CAAC;AACrE,eAAO,MAAM,aAAa,iBAA0C,CAAC;AACrE,eAAO,MAAM,aAAa,iBAA0C,CAAC;AAErE,MAAM,MAAM,cAAc,GACtB,OAAO,aAAa,GACpB,OAAO,aAAa,GACpB,OAAO,aAAa,GACpB,OAAO,aAAa,CAAC;AAEzB,eAAO,MAAM,4BAA4B,EAAE,SAAS,cAAc,EAIjE,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE5D,MAAM,MAAM,kBAAkB,GAAG,OAAO,CACtC,YAAY,EACZ;IAAE,IAAI,EAAE,QAAQ,CAAC;CAAE,CACpB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,QAAQ,CACjC,IAAI,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,EAAE,SAAS,CAAC,GACnD;IAAE,OAAO,EAAE,kBAAkB,CAAC;CAAE,CACnC,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,cAAc,CAAC;AAC9C,MAAM,MAAM,gBAAgB,GAAG,cAAc,CAAC;AAE9C,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CACrC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CACrC,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CACrC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CACrC,CAAC;AAEF,MAAM,MAAM,cAAc,GACtB,cAAc,GACd,gBAAgB,GAChB,gBAAgB,CAAC;AAErB,MAAM,MAAM,iBAAiB,GAAG;IAC9B,CAAC,aAAa,CAAC,EAAE,gBAAgB,CAAC;IAClC,CAAC,aAAa,CAAC,EAAE,gBAAgB,CAAC;IAClC,CAAC,aAAa,CAAC,EAAE,gBAAgB,CAAC;IAClC,CAAC,aAAa,CAAC,EAAE,gBAAgB,CAAC;CACnC,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,UAAU,CAAC,UAAU,CAAC,iBAAiB,CAAC,CAAC;AAElE;;;;;;GAMG;AACH,MAAM,MAAM,mBAAmB,GAC3B;IAAE,MAAM,EAAE,SAAS,CAAC;CAAE,GACtB;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,SAAS,eAAe,EAAE,CAAC;CAAE,GAC5D;IAAE,MAAM,EAAE,aAAa,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;CAAE,CAAC;AAE/C,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,MAAM,GAChB,OAAO,CAET;AAED,wBAAgB,eAAe,CAC7B,KAAK,EAAE,UAAU,CAAC,KAAK,GACtB,MAAM,CAAC,UAAU,EAAE,mBAAmB,CAAC,CA8BzC;AAED,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,mBAAmB,GAC7B,MAAM,CAWR;AAsCD,wBAAgB,aAAa,CAC3B,IAAI,EAAE,UAAU,GACf,kBAAkB,CAUpB;AAED,wBAAgB,aAAa,CAC3B,OAAO,EAAE,kBAAkB,GAC1B,UAAU,CAIZ"}

package/dist/events/AssetEvents.js

@@ -0,0 +1,102 @@
+// Import Node.js Dependencies
+import { Buffer } from "node:buffer";
+import { Err, Ok } from "@openally/result";
+import { Validator } from "ata-validator";
+// Import Internal Dependencies
+import { assetContentSchema, assetDeletedDataSchema, assetRenamedDataSchema, assetWriteDataSchema } from "./AssetEvents.schema.js";
+import { ASSET_EVENT_PREFIX } from "../constants.js";
+// CONSTANTS
+const kValidatorOptions = { useDefaults: false };
+const kWriteDataValidator = new Validator(assetWriteDataSchema, kValidatorOptions);
+const kRenamedDataValidator = new Validator(assetRenamedDataSchema, kValidatorOptions);
+const kDeletedDataValidator = new Validator(assetDeletedDataSchema, kValidatorOptions);
+export const ASSET_CREATED = `${ASSET_EVENT_PREFIX}created`;
+export const ASSET_UPDATED = `${ASSET_EVENT_PREFIX}updated`;
+export const ASSET_RENAMED = `${ASSET_EVENT_PREFIX}renamed`;
+export const ASSET_DELETED = `${ASSET_EVENT_PREFIX}deleted`;
+export const ASSET_CHECKPOINT_EVENT_TYPES = [
+    ASSET_CREATED,
+    ASSET_UPDATED,
+    ASSET_DELETED
+];
+export function isAssetEventType(eventType) {
+    return eventType.startsWith(ASSET_EVENT_PREFIX);
+}
+export function parseAssetEvent(event) {
+    switch (event.eventType) {
+        case ASSET_CREATED:
+        case ASSET_UPDATED:
+            return parseWriteEvent(event.eventType, event);
+        case ASSET_RENAMED: {
+            const result = kRenamedDataValidator.validate(event.eventData);
+            return result.valid ?
+                Ok({
+                    ...event,
+                    eventType: ASSET_RENAMED,
+                    eventData: result.data
+                }) :
+                Err(malformed(result.errors));
+        }
+        case ASSET_DELETED: {
+            const result = kDeletedDataValidator.validate(event.eventData);
+            return result.valid ?
+                Ok({
+                    ...event,
+                    eventType: ASSET_DELETED,
+                    eventData: result.data
+                }) :
+                Err(malformed(result.errors));
+        }
+        default:
+            return Err({ reason: "foreign" });
+    }
+}
+export function describeRejection(rejection) {
+    switch (rejection.reason) {
+        case "foreign":
+            return "event belongs to another domain";
+        case "unsupported":
+            return rejection.detail;
+        default:
+            return rejection.errors
+                .map((error) => `${error.instancePath || "/"} ${error.message}`)
+                .join("; ");
+    }
+}
+function parseWriteEvent(eventType, event) {
+    const result = kWriteDataValidator.validate(event.eventData);
+    if (!result.valid) {
+        return Err(malformed(result.errors));
+    }
+    const { content } = result.data;
+    if (content.type !== "inline") {
+        return Err({
+            reason: "unsupported",
+            detail: "content references are not supported yet"
+        });
+    }
+    return Ok({
+        ...event,
+        eventType,
+        eventData: {
+            ...result.data,
+            content
+        }
+    });
+}
+function malformed(errors) {
+    return {
+        reason: "malformed",
+        errors
+    };
+}
+export function encodeContent(data) {
+    return {
+        type: "inline",
+        encoding: "base64",
+        data: Buffer.from(data.buffer, data.byteOffset, data.byteLength).toString("base64")
+    };
+}
+export function decodeContent(content) {
+    return new Uint8Array(Buffer.from(content.data, "base64"));
+}

package/dist/events/AssetEvents.schema.d.ts

@@ -0,0 +1,111 @@
+export declare const assetContentSchema: {
+    readonly oneOf: readonly [{
+        readonly type: "object";
+        readonly properties: {
+            readonly type: {
+                readonly const: "inline";
+            };
+            readonly encoding: {
+                readonly const: "base64";
+            };
+            readonly data: {
+                readonly type: "string";
+            };
+        };
+        readonly required: readonly ["type", "encoding", "data"];
+    }, {
+        readonly type: "object";
+        readonly properties: {
+            readonly type: {
+                readonly const: "ref";
+            };
+            readonly hash: {
+                readonly type: "string";
+            };
+            readonly size: {
+                readonly type: "number";
+            };
+        };
+        readonly required: readonly ["type", "hash", "size"];
+    }];
+};
+export declare const assetWriteDataSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly path: {
+            readonly type: "string";
+        };
+        readonly kind: {
+            readonly type: "string";
+        };
+        readonly hash: {
+            readonly type: "string";
+        };
+        readonly size: {
+            readonly type: "number";
+        };
+        readonly content: {
+            readonly oneOf: readonly [{
+                readonly type: "object";
+                readonly properties: {
+                    readonly type: {
+                        readonly const: "inline";
+                    };
+                    readonly encoding: {
+                        readonly const: "base64";
+                    };
+                    readonly data: {
+                        readonly type: "string";
+                    };
+                };
+                readonly required: readonly ["type", "encoding", "data"];
+            }, {
+                readonly type: "object";
+                readonly properties: {
+                    readonly type: {
+                        readonly const: "ref";
+                    };
+                    readonly hash: {
+                        readonly type: "string";
+                    };
+                    readonly size: {
+                        readonly type: "number";
+                    };
+                };
+                readonly required: readonly ["type", "hash", "size"];
+            }];
+        };
+    };
+    readonly required: readonly ["path", "kind", "hash", "size", "content"];
+};
+export declare const assetRenamedDataSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly from: {
+            readonly type: "string";
+        };
+        readonly to: {
+            readonly type: "string";
+        };
+        readonly kind: {
+            readonly type: "string";
+        };
+        readonly hash: {
+            readonly type: "string";
+        };
+    };
+    readonly required: readonly ["from", "to", "kind", "hash"];
+};
+export declare const assetDeletedDataSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly path: {
+            readonly type: "string";
+        };
+        readonly kind: {
+            readonly type: "string";
+        };
+    };
+    readonly required: readonly ["path", "kind"];
+};
+//# sourceMappingURL=AssetEvents.schema.d.ts.map

package/dist/events/AssetEvents.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AssetEvents.schema.d.ts","sourceRoot":"","sources":["../../src/events/AssetEvents.schema.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6B7B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgB/B,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;CAcjC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;CAUjC,CAAC"}

package/dist/events/AssetEvents.schema.js

@@ -0,0 +1,75 @@
+// Import Third-party Dependencies
+import { defineSchema } from "ata-validator";
+export const assetContentSchema = defineSchema({
+    oneOf: [
+        {
+            type: "object",
+            properties: {
+                type: { const: "inline" },
+                encoding: { const: "base64" },
+                data: { type: "string" }
+            },
+            required: [
+                "type",
+                "encoding",
+                "data"
+            ]
+        },
+        {
+            type: "object",
+            properties: {
+                type: { const: "ref" },
+                hash: { type: "string" },
+                size: { type: "number" }
+            },
+            required: [
+                "type",
+                "hash",
+                "size"
+            ]
+        }
+    ]
+});
+export const assetWriteDataSchema = defineSchema({
+    type: "object",
+    properties: {
+        path: { type: "string" },
+        kind: { type: "string" },
+        hash: { type: "string" },
+        size: { type: "number" },
+        content: assetContentSchema
+    },
+    required: [
+        "path",
+        "kind",
+        "hash",
+        "size",
+        "content"
+    ]
+});
+export const assetRenamedDataSchema = defineSchema({
+    type: "object",
+    properties: {
+        from: { type: "string" },
+        to: { type: "string" },
+        kind: { type: "string" },
+        hash: { type: "string" }
+    },
+    required: [
+        "from",
+        "to",
+        "kind",
+        "hash"
+    ]
+});
+export const assetDeletedDataSchema = defineSchema({
+    type: "object",
+    properties: {
+        path: { type: "string" },
+        kind: { type: "string" }
+    },
+    required: [
+        "path",
+        "kind"
+    ]
+});

package/dist/events/index.d.ts

@@ -0,0 +1,3 @@
+export { ASSET_CHECKPOINT_EVENT_TYPES, ASSET_CREATED, ASSET_DELETED, ASSET_RENAMED, ASSET_UPDATED, decodeContent, describeRejection, encodeContent, isAssetEventType, parseAssetEvent } from "./AssetEvents.ts";
+export type { AssetContent, AssetCreatedData, AssetDeletedData, AssetEvent, AssetEventData, AssetEventDataMap, AssetEventRejection, AssetEventType, AssetInlineContent, AssetRenamedData, AssetUpdatedData, AssetWriteData } from "./AssetEvents.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/events/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/events/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,4BAA4B,EAC5B,aAAa,EACb,aAAa,EACb,aAAa,EACb,aAAa,EACb,aAAa,EACb,iBAAiB,EACjB,aAAa,EACb,gBAAgB,EAChB,eAAe,EAChB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EACV,YAAY,EACZ,gBAAgB,EAChB,gBAAgB,EAChB,UAAU,EACV,cAAc,EACd,iBAAiB,EACjB,mBAAmB,EACnB,cAAc,EACd,kBAAkB,EAClB,gBAAgB,EAChB,gBAAgB,EAChB,cAAc,EACf,MAAM,kBAAkB,CAAC"}

package/dist/events/index.js

@@ -0,0 +1 @@
+export { ASSET_CHECKPOINT_EVENT_TYPES, ASSET_CREATED, ASSET_DELETED, ASSET_RENAMED, ASSET_UPDATED, decodeContent, describeRejection, encodeContent, isAssetEventType, parseAssetEvent } from "./AssetEvents.js";

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./utils/index.ts";
+export * from "./kinds/index.ts";
+export * from "./events/index.ts";
+export * from "./sync/index.ts";
+export * from "./catalog/index.ts";
+export * from "./rooms/index.ts";
+export * from "./static/index.ts";
+export * from "./workspace/index.ts";
+export { createAssetBackend } from "./createAssetBackend.ts";
+export type { AssetBackend, AssetBackendInternals, AssetBackendOptions } from "./createAssetBackend.ts";
+export { silentLogger, type Logger } from "./logger.ts";
+export { ASSET_EVENT_PREFIX, EVENTS_DB_PATH, IDENTITY_SIDECAR_PATH, PROJECTION_STATE_PATH, STATE_DIRECTORY, STATE_GITIGNORE_PATH } from "./constants.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,YAAY,EACV,YAAY,EACZ,qBAAqB,EACrB,mBAAmB,EACpB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,YAAY,EACZ,KAAK,MAAM,EACZ,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,kBAAkB,EAClB,cAAc,EACd,qBAAqB,EACrB,qBAAqB,EACrB,eAAe,EACf,oBAAoB,EACrB,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,11 @@
+export * from "./utils/index.js";
+export * from "./kinds/index.js";
+export * from "./events/index.js";
+export * from "./sync/index.js";
+export * from "./catalog/index.js";
+export * from "./rooms/index.js";
+export * from "./static/index.js";
+export * from "./workspace/index.js";
+export { createAssetBackend } from "./createAssetBackend.js";
+export { silentLogger } from "./logger.js";
+export { ASSET_EVENT_PREFIX, EVENTS_DB_PATH, IDENTITY_SIDECAR_PATH, PROJECTION_STATE_PATH, STATE_DIRECTORY, STATE_GITIGNORE_PATH } from "./constants.js";

package/dist/kinds/AssetKindHandler.d.ts

@@ -0,0 +1,38 @@
+import type * as EventStore from "@jolly-pixel/event-store";
+import type { Extension } from "@jolly-pixel/network";
+import type { AssetLiveProtocol } from "../rooms/AssetRoomExtension.ts";
+export interface SnapshotPolicy {
+    /**
+     * Quiet period, in milliseconds, after the last event for an asset.
+     * `0` snapshots as soon as the current task yields.
+     * @default 2_000
+     */
+    delay?: number;
+    /**
+     * Upper bound, in milliseconds, between the first unsnapshotted event and
+     * its snapshot. Bounds data loss while an asset is edited continuously.
+     * @default 30_000
+     */
+    maxDelay?: number;
+}
+export interface AssetRoomBinding<TState = unknown> {
+    readonly assetId: string;
+    readonly kind: string;
+    readonly roomId: string;
+    readonly state: TState;
+}
+/**
+ * Folds an asset event stream and serializes its projected state.
+ */
+export interface AssetKindHandler<TState = unknown, TCommand = unknown> {
+    readonly kind: string;
+    readonly match: readonly string[];
+    readonly snapshot?: SnapshotPolicy;
+    readonly contentTypes?: Readonly<Record<string, string>>;
+    create(assetId: string): TState;
+    apply(state: TState, event: EventStore.Event): void;
+    serialize(state: TState): Promise<Uint8Array>;
+    live?(binding: AssetRoomBinding<TState>): AssetLiveProtocol<TCommand>;
+    createExtension?(binding: AssetRoomBinding<TState>): Extension;
+}
+//# sourceMappingURL=AssetKindHandler.d.ts.map

package/dist/kinds/AssetKindHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AssetKindHandler.d.ts","sourceRoot":"","sources":["../../src/kinds/AssetKindHandler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,UAAU,MAAM,0BAA0B,CAAC;AAC5D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAGtD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AAExE,MAAM,WAAW,cAAc;IAC7B;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,gBAAgB,CAAC,MAAM,GAAG,OAAO;IAChD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB,CAC/B,MAAM,GAAG,OAAO,EAChB,QAAQ,GAAG,OAAO;IAElB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,QAAQ,CAAC,EAAE,cAAc,CAAC;IACnC,QAAQ,CAAC,YAAY,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAEzD,MAAM,CACJ,OAAO,EAAE,MAAM,GACd,MAAM,CAAC;IAEV,KAAK,CACH,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,UAAU,CAAC,KAAK,GACtB,IAAI,CAAC;IAER,SAAS,CACP,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,UAAU,CAAC,CAAC;IAEvB,IAAI,CAAC,CACH,OAAO,EAAE,gBAAgB,CAAC,MAAM,CAAC,GAChC,iBAAiB,CAAC,QAAQ,CAAC,CAAC;IAE/B,eAAe,CAAC,CACd,OAAO,EAAE,gBAAgB,CAAC,MAAM,CAAC,GAChC,SAAS,CAAC;CACd"}

package/dist/kinds/AssetKindHandler.js

@@ -0,0 +1 @@
+export {};