@seedprotocol/sdk 0.7.9-next.1189.g5e63267 → 0.7.9

package/dist/BaseFileManager-BAlySv8w.js

@@ -0,0 +1,650 @@
+import debug from 'debug';
+import { sqliteTable, text, integer, unique, int, index, uniqueIndex, blob } from 'drizzle-orm/sqlite-core';
+import { relations, sql } from 'drizzle-orm';
+
+const logger = debug('seedSdk:browser:db:sqliteBusyRetry');
+/** Waits between attempts; about 1 s in total. */
+const SQLITE_BUSY_RETRY_DELAYS_MS = [25, 75, 150, 300, 450];
+/**
+ * Another connection (usually another tab) holds the database lock. SQLite reports this as
+ * SQLITE_BUSY ("database is locked") or SQLITE_LOCKED ("database table is locked").
+ */
+function isSqliteBusyError(error) {
+    // Drizzle wraps a driver's error ("Failed query: ...") and keeps it as `cause`
+    for (let current = error, depth = 0; current != null && depth < 5; depth++) {
+        const message = current instanceof Error ? current.message : String(current);
+        if (/SQLITE_BUSY|SQLITE_LOCKED|database (table )?is locked/i.test(message))
+            return true;
+        current = current.cause;
+    }
+    return false;
+}
+/**
+ * Retries a statement another tab's lock rejected. Safe for the SDK's writes because each is a
+ * single autocommit statement: one that failed with SQLITE_BUSY didn't apply. Don't use this for
+ * statements inside a transaction, where a retry would replay part of it.
+ */
+function withSqliteBusyRetry(driver, delaysMs = SQLITE_BUSY_RETRY_DELAYS_MS) {
+    return async (...args) => {
+        for (let attempt = 0;; attempt++) {
+            try {
+                return await driver(...args);
+            }
+            catch (error) {
+                if (!isSqliteBusyError(error) || attempt >= delaysMs.length)
+                    throw error;
+                logger(`database busy (attempt ${attempt + 1}); retrying`);
+                await new Promise((resolve) => setTimeout(resolve, delaysMs[attempt]));
+            }
+        }
+    };
+}
+
+class BaseDb {
+    static configure(impl) {
+        if (!impl) {
+            throw new Error('Cannot configure Db with undefined or null. Ensure the platform-specific Db is properly created.');
+        }
+        BaseDb._impl = impl;
+    }
+    static requireImpl() {
+        if (!BaseDb._impl) {
+            throw new Error('Db not configured. Call BaseDb.configure() during platform init.');
+        }
+        return BaseDb._impl;
+    }
+    static getAppDb() {
+        return BaseDb.requireImpl().getAppDb();
+    }
+    static prepareDb(filesDir, config) {
+        return BaseDb.requireImpl().prepareDb(filesDir, config);
+    }
+    static isAppDbReady() {
+        if (!BaseDb._impl) {
+            return false;
+        }
+        return BaseDb._impl.isAppDbReady();
+    }
+    static connectToDb(pathToDir) {
+        return BaseDb.requireImpl().connectToDb(pathToDir);
+    }
+    static async migrate(pathToDbDir, dbName, dbId) {
+        return BaseDb.requireImpl().migrate(pathToDbDir, dbName, dbId);
+    }
+    /**
+     * Execute a reactive query that emits new results whenever the underlying data changes.
+     *
+     * Supports two usage patterns:
+     * 1. SQL tag function (browser only): liveQuery((sql) => sql`SELECT * FROM models`)
+     * 2. Drizzle query builder: liveQuery(db.select().from(models))
+     *
+     * On Node only the query builder works (a tag function throws), and it is re-run every second;
+     * the observable emits when the result changes.
+     */
+    static liveQuery(query) {
+        return BaseDb.requireImpl().liveQuery(query);
+    }
+    /**
+     * Runs `fn` in one transaction: every query it runs on `tx` (a Drizzle database, used like
+     * `getAppDb()`) commits together, or none does when `fn` throws. Queries on `getAppDb()` inside
+     * `fn` are not part of the transaction, and in the browser they wait for it to end, so don't
+     * call `getAppDb()` or `BaseDb.transaction` from `fn`.
+     *
+     * When another connection (another tab) holds the database lock, the whole transaction is
+     * retried, so `fn` must have no side effects outside `tx`.
+     */
+    static async transaction(fn) {
+        const impl = BaseDb.requireImpl();
+        for (let attempt = 0;; attempt++) {
+            try {
+                return await impl.transaction(fn);
+            }
+            catch (error) {
+                if (!isSqliteBusyError(error) || attempt >= SQLITE_BUSY_RETRY_DELAYS_MS.length)
+                    throw error;
+                await new Promise((resolve) => setTimeout(resolve, SQLITE_BUSY_RETRY_DELAYS_MS[attempt]));
+            }
+        }
+    }
+}
+BaseDb._impl = null;
+
+const models = sqliteTable('models', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    name: text('name').notNull(),
+    schemaFileId: text('schema_file_id'), // ID from JSON file for change tracking - must be unique
+    isEdited: integer('is_edited', { mode: 'boolean' }), // true if model has been edited locally, false if matches schema file
+}, (table) => {
+    return {
+        uniqueSchemaFileId: unique('unique_schema_file_id').on(table.schemaFileId),
+    };
+});
+const modelsRelations = relations(models, ({ many }) => ({
+    properties: many(properties),
+}));
+const properties = sqliteTable('properties', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    name: text('name').notNull(),
+    dataType: text('data_type').notNull(),
+    modelId: integer('model_id')
+        .notNull()
+        .references(() => models.id),
+    refModelId: integer('ref_model_id').references(() => models.id),
+    refValueType: text('ref_value_type'),
+    schemaFileId: text('schema_file_id'), // ID from JSON file for change tracking
+    isEdited: integer('is_edited', { mode: 'boolean' }), // true if property has been edited locally, false if matches schema file
+    required: integer('required', { mode: 'boolean' }), // true if relation/image property is required (publish fails when related item not found)
+    // Storage settings from the schema file's `storage: { type, path, extension }`, in the internal
+    // shape ModelProperty uses. Null when the property has no storage config.
+    storageType: text('storage_type'), // 'ItemStorage' | 'PropertyStorage'
+    localStorageDir: text('local_storage_dir'), // storage.path, e.g. '/html'
+    filenameSuffix: text('filename_suffix'), // storage.extension, e.g. '.html'
+    // The whole definition as JSON: the schema file's property object, or a code-defined one
+    // (validation, htmlEmbeddedDataUriPolicy, description and any other field). The columns above
+    // win for the fields they hold. Read through helpers/propertyDefinition.
+    definition: text('definition'),
+}, (table) => {
+    return {
+        uniqueNameModelId: unique('unique_name_model_id').on(table.name, table.modelId),
+        uniqueSchemaFileId: unique('unique_property_schema_file_id').on(table.schemaFileId),
+    };
+});
+const propertiesRelations = relations(properties, ({ one }) => ({
+    model: one(models),
+    refModel: one(models),
+}));
+
+/**
+ * True for a stored attestation uid, false for the placeholders a draft row holds (NULL, '',
+ * 'NULL', ZERO_BYTES32; see `isPlaceholderUid` in @seedprotocol/eas). The predicate of the partial
+ * unique indexes on `seeds.uid` and `versions.uid`.
+ */
+const attestedUidSql = (column) => sql `${column} IS NOT NULL AND trim(${column}) NOT IN ('', 'NULL') AND lower(trim(${column})) != '0x0000000000000000000000000000000000000000000000000000000000000000'`;
+
+const seeds = sqliteTable('seeds', {
+    localId: text('local_id').unique(),
+    uid: text('uid'),
+    schemaUid: text('schema_uid'),
+    type: text('type'),
+    // schemaFileId of the models row this item belongs to (= Model.id). Disambiguates items whose
+    // model name exists in more than one schema; null for legacy rows that couldn't be backfilled.
+    modelFileId: text('model_file_id'),
+    publisher: text('publisher'),
+    attestationRaw: text('attestation_raw'),
+    attestationCreatedAt: int('attestation_created_at'),
+    // Set on insert when the writer leaves it out. No $onUpdate: readers rank rows by
+    // COALESCE(attestation_created_at, created_at), and some writers move it on purpose.
+    createdAt: int('created_at').$defaultFn(() => Date.now()),
+    // Set on every insert and update unless the writer passes a value.
+    updatedAt: int('updated_at')
+        .$defaultFn(() => Date.now())
+        .$onUpdate(() => Date.now()),
+    _markedForDeletion: int('_marked_for_deletion'),
+    revokedAt: int('revoked_at'),
+}, (table) => [
+    index('seeds_uid_idx').on(table.uid),
+    index('seeds_type_idx').on(table.type),
+    // One row per attested seed uid (migration 0029). Drafts hold a placeholder uid and are left out.
+    uniqueIndex('seeds_attested_uid_unique').on(table.uid).where(attestedUidSql(table.uid)),
+]);
+
+const versions = sqliteTable('versions', {
+    localId: text('local_id').unique(),
+    uid: text('uid'),
+    seedLocalId: text('seed_local_id'),
+    seedUid: text('seed_uid'),
+    seedType: text('seed_type'),
+    note: text('note'),
+    // Set on insert when the writer leaves it out. No $onUpdate: readers rank rows by
+    // COALESCE(attestation_created_at, created_at), and some writers move it on purpose.
+    createdAt: int('created_at').$defaultFn(() => Date.now()),
+    // Set on every insert and update unless the writer passes a value.
+    updatedAt: int('updated_at')
+        .$defaultFn(() => Date.now())
+        .$onUpdate(() => Date.now()),
+    attestationCreatedAt: int('attestation_created_at'),
+    attestationRaw: text('attestation_raw'),
+    publisher: text('publisher'),
+    /**
+     * When the version attestation was revoked, in Unix seconds (EAS `revocationTime`, or the local
+     * unpublish time until sync confirms it). Null while live or unpublished.
+     */
+    revokedAt: int('revoked_at'),
+}, (table) => [
+    index('versions_seed_local_id_idx').on(table.seedLocalId),
+    // One row per attested version uid (migration 0029). Drafts hold a placeholder uid and are left out.
+    uniqueIndex('versions_attested_uid_unique').on(table.uid).where(attestedUidSql(table.uid)),
+]);
+
+const metadata = sqliteTable('metadata', {
+    localId: text('local_id').unique(),
+    uid: text('uid'),
+    propertyId: integer('property_id').references(() => properties.id),
+    propertyName: text('property_name'),
+    propertyValue: text('property_value'),
+    schemaUid: text('schema_uid'),
+    modelType: text('model_type'),
+    seedLocalId: text('seed_local_id'),
+    seedUid: text('seed_uid'),
+    versionLocalId: text('version_local_id'),
+    versionUid: text('version_uid'),
+    easDataType: text('eas_data_type'),
+    refValueType: text('ref_value_type'),
+    refModelUid: text('ref_schema_uid'),
+    refSeedType: text('ref_seed_type'),
+    refResolvedValue: text('ref_resolved_value'),
+    refResolvedDisplayValue: text('ref_resolved_display_value'),
+    localStorageDir: text('local_storage_dir'),
+    attestationRaw: text('attestation_raw'),
+    attestationCreatedAt: int('attestation_created_at'),
+    contentHash: text('content_hash'),
+    // Set on insert when the writer leaves it out. No $onUpdate: readers rank rows by
+    // COALESCE(attestation_created_at, created_at), and some writers move it on purpose.
+    createdAt: int('created_at').$defaultFn(() => Date.now()),
+    // Set on every insert and update unless the writer passes a value.
+    updatedAt: int('updated_at')
+        .$defaultFn(() => Date.now())
+        .$onUpdate(() => Date.now()),
+    publisher: text('publisher'),
+    // Unix seconds when this row's attestation was revoked on EAS; null while it's live (or for a
+    // local, unpublished row). EAS sync keeps only the canonical attestation per (version, property
+    // schema): the newest live one, or the newest revoked one when all are revoked. So a non-null
+    // value marks a property kept only for its last value, not one that is present on the version.
+    revokedAt: int('revoked_at'),
+    // For a row EAS sync derived for an ItemStorage property from a `storage_transaction_id`
+    // attestation (uid null, ref_value_type 'file', value = the transaction id): that attestation's
+    // uid. Null for every other row. Marks the row as published content, not a local draft.
+    derivedFromUid: text('derived_from_uid'),
+    // On a cleared local row (null value): publish revokes the property's attestations instead of
+    // attesting the empty value (ADR 0021). Null on every other row.
+    retract: int('retract', { mode: 'boolean' }),
+}, (table) => [
+    index('metadata_seed_local_id_property_name_idx').on(table.seedLocalId, table.propertyName),
+    index('metadata_seed_uid_idx').on(table.seedUid),
+]);
+
+const appState = sqliteTable('appState', {
+    key: text('key').unique(),
+    value: text('value'),
+    createdAt: int('created_at'),
+    updatedAt: int('updated_at'),
+});
+
+const modelUids = sqliteTable('model_uids', {
+    id: int('id').primaryKey({ autoIncrement: true }),
+    uid: text('uid').notNull(),
+    modelId: int('model_id')
+        .notNull()
+        .unique()
+        .references(() => models.id),
+});
+const modelRelations = relations(modelUids, ({ one }) => ({
+    model: one(models),
+}));
+
+const propertyUids = sqliteTable('property_uids', {
+    id: int('id').primaryKey({ autoIncrement: true }),
+    uid: text('uid').notNull(),
+    propertyId: int('property_id')
+        .notNull()
+        .unique()
+        .references(() => properties.id),
+});
+const propertyUidRelations = relations(propertyUids, ({ one }) => ({
+    property: one(properties),
+}));
+
+const config = sqliteTable('config', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    key: text('key').notNull(),
+    text: text('text'),
+    json: text('json'),
+    blob: blob('blob'),
+});
+
+const schemas = sqliteTable('schemas', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    name: text('name').notNull(),
+    version: integer('version').notNull(),
+    schemaFileId: text('schema_file_id'), // ID from JSON file for change tracking - must be unique
+    schemaData: text('schema_data'), // Full JSON schema content (SchemaFileFormat as JSON string)
+    isDraft: integer('is_draft', { mode: 'boolean' }), // true if schema is in draft/editing state, false if published to file
+    isEdited: integer('is_edited', { mode: 'boolean' }), // true if schema has been edited locally, false if matches schema file
+    // Hash of the schema file applySchemaFile last wrote to the rows (with schema_file_id and
+    // version): a file with the same three is not applied again.
+    contentHash: text('content_hash'),
+    createdAt: int('created_at'),
+    updatedAt: int('updated_at'),
+}, (table) => {
+    return {
+        uniqueSchemaFileId: unique('unique_schema_schema_file_id').on(table.schemaFileId),
+    };
+});
+
+var SchemaSchema = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    schemas: schemas
+});
+
+const modelSchemas = sqliteTable('model_schemas', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    modelId: integer('model_id').references(() => models.id),
+    schemaId: integer('schema_id').references(() => schemas.id),
+}, (table) => [
+    // One link per model and schema (migration 0029)
+    unique('model_schemas_model_id_schema_id_unique').on(table.modelId, table.schemaId),
+]);
+
+var ModelSchemaSchema = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    modelSchemas: modelSchemas
+});
+
+const publishProcesses = sqliteTable('publish_processes', {
+    id: int('id').primaryKey({ autoIncrement: true }),
+    seedLocalId: text('seed_local_id').notNull(),
+    modelName: text('model_name').notNull(),
+    schemaId: text('schema_id'),
+    status: text('status').notNull(), // 'in_progress' | 'completed' | 'failed' | 'interrupted'
+    startedAt: int('started_at').notNull(),
+    completedAt: int('completed_at'),
+    errorMessage: text('error_message'),
+    errorStep: text('error_step'),
+    errorDetails: text('error_details'),
+    errorCode: text('error_code'), // e.g. ManagedAccountPublishError.code
+    persistedSnapshot: text('persisted_snapshot').notNull(),
+    seedId: text('seed_id'),
+    existingSeedUid: text('existing_seed_uid'),
+    createdAt: int('created_at'),
+    updatedAt: int('updated_at'),
+});
+
+const uploadProcesses = sqliteTable('upload_processes', {
+    id: int('id').primaryKey({ autoIncrement: true }),
+    reimbursementConfirmed: int('reimbursement_confirmed').notNull(), // 0 or 1 for boolean
+    reimbursementTransactionId: text('reimbursement_transaction_id'),
+    transactionKeys: text('transaction_keys'),
+    persistedSnapshot: text('persisted_snapshot').notNull(), // JSON string
+    createdAt: int('created_at'),
+    updatedAt: int('updated_at'),
+});
+
+/** Background job: resolve L1 tx id and wait for L1 confirmation after bundler publish. */
+const arweaveL1FinalizeJobs = sqliteTable('arweave_l1_finalize_jobs', {
+    id: int('id').primaryKey({ autoIncrement: true }),
+    seedLocalId: text('seed_local_id').notNull(),
+    dataItemId: text('data_item_id').notNull(),
+    /** L1 bundle / anchor transaction id from gateway GraphQL `bundledIn.id`. */
+    l1TransactionId: text('l1_transaction_id'),
+    bundleId: text('bundle_id'),
+    versionLocalId: text('version_local_id'),
+    itemPropertyName: text('item_property_name'),
+    /** `pending_l1` | `confirmed` | `failed` */
+    phase: text('phase').notNull(),
+    statusJson: text('status_json'),
+    errorMessage: text('error_message'),
+    createdAt: int('created_at').notNull(),
+    updatedAt: int('updated_at').notNull(),
+}, (table) => ({
+    dataItemIdUnique: uniqueIndex('arweave_l1_finalize_jobs_data_item_id_unique').on(table.dataItemId),
+}));
+
+const easSyncProcesses = sqliteTable('eas_sync_processes', {
+    id: int('id').primaryKey({ autoIncrement: true }),
+    status: text('status').notNull(), // 'in_progress' | 'completed' | 'failed'
+    startedAt: int('started_at').notNull(),
+    completedAt: int('completed_at'),
+    requestPayload: text('request_payload').notNull(),
+    errorMessage: text('error_message'),
+    errorDetails: text('error_details'),
+    persistedSnapshot: text('persisted_snapshot').notNull(),
+    createdAt: int('created_at'),
+    updatedAt: int('updated_at'),
+});
+
+/**
+ * Links Image seeds materialized from Html `data:image/*` URIs to the parent Item seed for co-publish.
+ * Rows are removed after a successful publish (see clearHtmlEmbeddedImageCoPublishRows).
+ */
+const htmlEmbeddedImageCoPublish = sqliteTable('html_embedded_image_co_publish', {
+    id: int('id').primaryKey({ autoIncrement: true }),
+    parentSeedLocalId: text('parent_seed_local_id').notNull(),
+    htmlSeedLocalId: text('html_seed_local_id').notNull(),
+    imageSeedLocalId: text('image_seed_local_id').notNull(),
+    /** Stable dedup key (e.g. sha256 of data URI or normalized URI string). */
+    stableKey: text('stable_key').notNull(),
+    createdAt: int('created_at').notNull(),
+}, (t) => [
+    uniqueIndex('html_embed_co_pub_parent_html_stable').on(t.parentSeedLocalId, t.htmlSeedLocalId, t.stableKey),
+]);
+
+/**
+ * The item write outbox (ADR 0019): one row per edit to an item, appended when the value is
+ * assigned and applied to `seeds`, `versions` and `metadata` by the leader tab's drainer.
+ */
+const pendingWrites = sqliteTable('pending_writes', {
+    id: int('id').primaryKey({ autoIncrement: true }),
+    /** Unique per op; the drainer and `save()` refer to an op by it. */
+    opId: text('op_id').notNull(),
+    /** Unused: nothing appends grouped ops. Kept until a migration drops it. */
+    groupId: text('group_id'),
+    seedLocalId: text('seed_local_id').notNull(),
+    /** Null for ops on the seed itself (`create`, `delete`). */
+    propertyName: text('property_name'),
+    /** `create` | `set` | `delete` | `storage` */
+    kind: text('kind').notNull(),
+    /** JSON-encoded value. */
+    value: text('value'),
+    /**
+     * A storage op's staged file: the assigned bytes, written by the tab that appended the op (an
+     * ItemStorage op's staged path is in its JSON value too).
+     */
+    valueRef: text('value_ref'),
+    /** The stored metadata row the edit was made against, to detect a synced row written since. */
+    baseRowId: text('base_row_id'),
+    /** Unused: the base uid is read through base_row_id. Kept until a migration drops it. */
+    baseUid: text('base_uid'),
+    createdAt: int('created_at').notNull(),
+    /** The tab that appended the op. */
+    tabId: text('tab_id'),
+    /** `pending` | `applied` | `superseded` | `failed`. An op is claimed and applied in one transaction. */
+    status: text('status').notNull(),
+    error: text('error'),
+    /** The name of the error that failed the op (`OwnershipError`, say), so a waiter can tell why. */
+    errorName: text('error_name'),
+    attempts: int('attempts').notNull().default(0),
+    appliedAt: int('applied_at'),
+    /** JSON the applier recorded when the op applied (for a `set`: the metadata row written). */
+    result: text('result'),
+    /** JSON: the synced value this op was applied over, when there was one (ADR 0019). */
+    conflict: text('conflict'),
+    conflictResolvedAt: int('conflict_resolved_at'),
+}, (table) => ({
+    opIdUnique: uniqueIndex('pending_writes_op_id_unique').on(table.opId),
+    /** The drainer's order: per property, oldest first, among one status. */
+    drainOrder: index('pending_writes_drain_order').on(table.status, table.seedLocalId, table.propertyName, table.createdAt),
+}));
+
+/**
+ * The entity change log (ADR 0020): one row per row written to `seeds`, `versions` or `metadata`,
+ * inserted by triggers (migration 0023), so it commits or rolls back with the write. The browser's
+ * change feed reads it to tell loaded Items and ItemProperties which seeds changed. Nothing else
+ * writes it; the leader tab prunes rows older than 10 minutes.
+ */
+const entityChanges = sqliteTable('entity_changes', {
+    seq: int('seq').primaryKey({ autoIncrement: true }),
+    /** `seeds` | `versions` | `metadata` */
+    tbl: text('tbl').notNull(),
+    seedLocalId: text('seed_local_id'),
+    seedUid: text('seed_uid'),
+    /** Set for `metadata` rows only. */
+    propertyName: text('property_name'),
+    /** Unix ms when the trigger ran. */
+    at: int('at').notNull(),
+}, (table) => ({
+    at: index('entity_changes_at').on(table.at),
+}));
+
+class BaseFileManager {
+    static configure(impl) {
+        if (!impl) {
+            throw new Error('Cannot configure FileManager with undefined or null. Ensure the platform-specific FileManager is properly created.');
+        }
+        BaseFileManager._impl = impl;
+    }
+    static requireImpl() {
+        if (!BaseFileManager._impl) {
+            throw new Error('FileManager not configured. Call BaseFileManager.configure() during platform init.');
+        }
+        return BaseFileManager._impl;
+    }
+    /**
+     * Clears FS init flags so a later call can retry. Used after a failed init
+     * and by tests. Does not unmount or delete any files.
+     */
+    static resetInitializationState() {
+        this.fileSystemInitialized = false;
+        this.initializing = false;
+        this.initializePromise = null;
+        this.workingDir = undefined;
+    }
+    static initializeFileSystem(workingDir) {
+        if (this.fileSystemInitialized) {
+            return Promise.resolve();
+        }
+        if (this.initializePromise) {
+            return this.initializePromise;
+        }
+        this.initializing = true;
+        const pending = this.runInitializeFileSystem(workingDir).finally(() => {
+            this.initializing = false;
+            if (this.initializePromise === pending) {
+                this.initializePromise = null;
+            }
+        });
+        this.initializePromise = pending;
+        return pending;
+    }
+    static async runInitializeFileSystem(workingDir) {
+        await BaseFileManager.requireImpl().initializeFileSystem(workingDir);
+        this.fileSystemInitialized = true;
+        this.workingDir = workingDir;
+    }
+    static getWorkingDir() {
+        if (!this.workingDir) {
+            throw new Error('Working directory is not set');
+        }
+        return this.workingDir;
+    }
+    /**
+     * Build a path under the configured files root (e.g. /app-files).
+     * Use this instead of hardcoding /files/ for images, html, json, etc.
+     * @param subpaths - path segments to join (e.g. 'images', fileName)
+     * @returns full path like /app-files/images/egg.jpg
+     */
+    static getFilesPath(...subpaths) {
+        const root = this.getWorkingDir().replace(/\/$/, '');
+        const parts = [root, ...subpaths].filter(Boolean);
+        return parts.join('/').replace(/\/+/g, '/');
+    }
+    static getContentUrlFromPath(path) {
+        return BaseFileManager.requireImpl().getContentUrlFromPath(path);
+    }
+    static downloadAllFiles(params) {
+        return BaseFileManager.requireImpl().downloadAllFiles(params);
+    }
+    static downloadFileByTransactionId({ transactionId, arweaveHost, arweaveBaseUrls, excludedTransactions, expectedContentHash, compositeChildPaths, skipExisting, }) {
+        return BaseFileManager.requireImpl().downloadAllFiles({
+            transactionIds: [transactionId],
+            arweaveHost,
+            arweaveBaseUrls,
+            excludedTransactions,
+            expectedContentHashes: expectedContentHash ? { [transactionId]: expectedContentHash } : undefined,
+            compositeChildPaths: compositeChildPaths ? { [transactionId]: compositeChildPaths } : undefined,
+            skipExisting,
+        });
+    }
+    static resizeImage({ filePath, width, height }) {
+        return BaseFileManager.requireImpl().resizeImage({ filePath, width, height });
+    }
+    static resizeAllImages({ width, height }) {
+        return BaseFileManager.requireImpl().resizeAllImages({ width, height });
+    }
+    static pathExists(filePath) {
+        return BaseFileManager.requireImpl().pathExists(filePath);
+    }
+    static invalidateCachedPaths(filePaths) {
+        return BaseFileManager.requireImpl().invalidateCachedPaths(filePaths);
+    }
+    /** File size in bytes, or null if the path does not exist / cannot be stated. */
+    static getFileSize(filePath) {
+        return BaseFileManager.requireImpl().getFileSize(filePath);
+    }
+    /**
+     * Returns a list of filenames in the given directory (e.g. 'images', 'files').
+     */
+    static listFiles(dir) {
+        return BaseFileManager.requireImpl().listFiles(dir);
+    }
+    /**
+     * Returns a list of image filenames in the images folder (originals only, excludes size subdirs).
+     * Use this to get all stored images without traversing 480/760/1024/1440/1920 subdirectories.
+     */
+    static listImageFiles() {
+        return this.listFiles('images');
+    }
+    static createDirIfNotExists(filePath) {
+        return BaseFileManager.requireImpl().createDirIfNotExists(filePath);
+    }
+    static async waitForFile(filePath) {
+        return BaseFileManager.requireImpl().waitForFile(filePath);
+    }
+    static async waitForFileWithContent(filePath, interval, timeout) {
+        return BaseFileManager.requireImpl().waitForFileWithContent(filePath, interval, timeout);
+    }
+    static async saveFile(filePath, content) {
+        return BaseFileManager.requireImpl().saveFile(filePath, content);
+    }
+    static saveFileSync(filePath, content) {
+        return BaseFileManager.requireImpl().saveFileSync(filePath, content);
+    }
+    static async readFile(filePath) {
+        return BaseFileManager.requireImpl().readFile(filePath);
+    }
+    static readFileSync(filePath) {
+        return BaseFileManager.requireImpl().readFileSync(filePath);
+    }
+    static async readFileAsBuffer(filePath) {
+        return BaseFileManager.requireImpl().readFileAsBuffer(filePath);
+    }
+    static async readFileAsString(filePath) {
+        return BaseFileManager.requireImpl().readFileAsString(filePath);
+    }
+    static async getFs() {
+        return BaseFileManager.requireImpl().getFs();
+    }
+    static getFsSync() {
+        return BaseFileManager.requireImpl().getFsSync();
+    }
+    static getPathModule() {
+        return BaseFileManager.requireImpl().getPathModule();
+    }
+    static getParentDirPath(filePath) {
+        return BaseFileManager.requireImpl().getParentDirPath(filePath);
+    }
+    static getFilenameFromPath(filePath) {
+        return BaseFileManager.requireImpl().getFilenameFromPath(filePath);
+    }
+}
+BaseFileManager.fileSystemInitialized = false;
+BaseFileManager.initializing = false;
+BaseFileManager._impl = null;
+BaseFileManager.initializePromise = null;
+
+var BaseFileManager$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    BaseFileManager: BaseFileManager
+});
+
+export { BaseFileManager$1 as A, BaseDb as B, ModelSchemaSchema as M, SQLITE_BUSY_RETRY_DELAYS_MS as S, appState as a, modelUids as b, config as c, models as d, arweaveL1FinalizeJobs as e, easSyncProcesses as f, entityChanges as g, htmlEmbeddedImageCoPublish as h, modelRelations as i, modelSchemas as j, modelsRelations as k, properties as l, metadata as m, propertiesRelations as n, propertyUidRelations as o, pendingWrites as p, propertyUids as q, publishProcesses as r, seeds as s, schemas as t, uploadProcesses as u, versions as v, BaseFileManager as w, isSqliteBusyError as x, withSqliteBusyRetry as y, SchemaSchema as z };
+//# sourceMappingURL=BaseFileManager-BAlySv8w.js.map