@seedprotocol/sdk 0.3.30 → 0.4.0

package/dist/src/services/global/globalMachine.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"globalMachine.d.ts","sourceRoot":"","sources":["../../../../src/services/global/globalMachine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAqC,MAAM,QAAQ,CAAA;AAExE,OAAO,EAKL,WAAW,EACX,UAAU,EACX,MAAM,+BAA+B,CAAA;AACtC,OAAO,EAAE,oBAAoB,EAAkB,MAAM,SAAS,CAAA;AAsB9D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAcgB,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgKrD,CAAA;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAlKgB,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4NrD,CAAA;AAIF,QAAA,MAAM,gBAAgB,QAAO,YAAY,CAAC,OAAO,aAAa,CAAkB,CAAA;AAEhF,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,aAAa,EAAE,CAAA"}

package/dist/src/services/global/globalMachine.js

@@ -1,246 +0,0 @@
-import { setup, assign, raise, createActor } from 'xstate';
-import { createBrowserInspector } from '@statelyai/inspect';
-import { GlobalState, MachineIds, GLOBAL_ADDING_MODELS_TO_DB_SUCCESS, GLOBAL_INITIALIZING_CREATE_ALL_ITEMS_SERVICES, GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY, GLOBAL_INITIALIZING_SEND_CONFIG } from '../internal/constants.js';
-import { eventEmitter } from '../../eventBus.js';
-import { initialize } from './actors/initialize.js';
-import { getSchemaForModel } from './actors/getSchemaForModel.js';
-import { addModelsToDb } from './actors/addModelsToDb.js';
-import { itemMachineAll } from '../allItems/itemMachineAll.js';
-import { publishMachine } from '../publish/publishMachine.js';
-import { savePublishService } from './actors/savePublishService.js';
-import { internalMachine } from '../internal/internalMachine.js';
-
-const { UNINITIALIZED, INITIALIZING, INITIALIZED, PUBLISHING_ITEM, ADDING_MODELS_TO_DB, } = GlobalState;
-const { inspect } = createBrowserInspector({
-    autoStart: false,
-});
-const globalMachine = setup({
-    types: {
-        context: {},
-        input: {},
-    },
-    actors: {
-        initialize,
-        addModelsToDb,
-        getSchemaForModel,
-        savePublishService,
-    },
-}).createMachine({
-    id: MachineIds.GLOBAL,
-    initial: UNINITIALIZED,
-    context: ({ input }) => input,
-    on: {
-        publishItemRequest: `.${PUBLISHING_ITEM}`,
-        savePublishService: `.savingPublishService`,
-        restorePublishService: `.${PUBLISHING_ITEM}`,
-    },
-    states: {
-        [UNINITIALIZED]: {
-            on: {
-                init: {
-                    target: INITIALIZING,
-                    actions: [
-                        assign({
-                            isInitialized: false,
-                            addedModelRecordsToDb: false,
-                            models: ({ event }) => event.models,
-                            endpoints: ({ event }) => event.endpoints,
-                            filesDir: ({ event }) => event.filesDir,
-                            internalService: ({ spawn, event }) => {
-                                return spawn(internalMachine, {
-                                    systemId: MachineIds.INTERNAL,
-                                    input: {
-                                        endpoints: event.endpoints,
-                                        filesDir: event.filesDir,
-                                        addresses: event.addresses,
-                                        arweaveDomain: event.arweaveDomain,
-                                    },
-                                });
-                            },
-                        }),
-                    ],
-                },
-            },
-            meta: {
-                displayText: 'Booting up',
-                percentComplete: 5,
-            },
-            tags: ['loading', 'startup'],
-        },
-        [INITIALIZING]: {
-            on: {
-                [GLOBAL_INITIALIZING_SEND_CONFIG]: {
-                    actions: assign({
-                        endpoints: ({ event }) => event.endpoints,
-                        environment: ({ event }) => event.environment,
-                        addresses: ({ event }) => event.addresses,
-                        isInitialized: true,
-                    }),
-                },
-                [GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY]: ADDING_MODELS_TO_DB,
-                [GLOBAL_INITIALIZING_CREATE_ALL_ITEMS_SERVICES]: {
-                    actions: [
-                        assign(({ event, spawn }) => {
-                            const allItemsServices = {};
-                            for (const [modelName, ModelClass] of Object.entries(event.create)) {
-                                const service = spawn(itemMachineAll, {
-                                    systemId: modelName,
-                                    input: {
-                                        modelName,
-                                        ModelClass,
-                                        modelSchema: ModelClass.schema,
-                                        items: [],
-                                    },
-                                });
-                                allItemsServices[`${modelName}Service`] = service;
-                            }
-                            for (const [modelName, snapshot] of Object.entries(event.restore)) {
-                                const service = createActor(itemMachineAll, {
-                                    snapshot,
-                                });
-                                service.start();
-                                allItemsServices[`${modelName}Service`] = service;
-                            }
-                            return allItemsServices;
-                        }),
-                        raise({ type: 'allItemsServicesCreated' }),
-                    ],
-                },
-            },
-            invoke: {
-                src: 'initialize',
-                input: ({ event, context }) => ({ event, context }),
-                meta: {
-                    displayText: 'Initializing Seed SDK',
-                    percentComplete: 10,
-                },
-                tags: ['loading', 'startup'],
-            },
-        },
-        [ADDING_MODELS_TO_DB]: {
-            on: {
-                [GLOBAL_ADDING_MODELS_TO_DB_SUCCESS]: {
-                    target: INITIALIZED,
-                    actions: assign({
-                        addedModelRecordsToDb: true,
-                    }),
-                },
-            },
-            invoke: {
-                src: 'addModelsToDb',
-                input: ({ context }) => ({ context }),
-                meta: {
-                    displayText: 'Adding models to database',
-                },
-                tags: ['loading', 'startup'],
-            },
-        },
-        [INITIALIZED]: {
-            // type: 'parallel',
-            // on: {
-            //   publishItemRequest: `.${PUBLISHING_ITEM}`,
-            // },
-            meta: {
-                displayText: 'Global service ready',
-                percentComplete: 40,
-            },
-            tags: ['loading', 'startup'],
-            // initial: PUBLISHING_ITEM,
-        },
-        [PUBLISHING_ITEM]: {
-            target: INITIALIZED,
-            entry: [
-                assign({
-                    publishItemService: ({ spawn, event }) => spawn(publishMachine, {
-                        id: 'publishService',
-                        input: {
-                            localId: event.seedLocalId,
-                        },
-                    }),
-                }),
-            ],
-            meta: {
-                displayText: 'Publishing item',
-            },
-            tags: ['publishing'],
-        },
-        savingPublishService: {
-            target: INITIALIZED,
-            on: {
-                savePublishServiceSuccess: INITIALIZED,
-            },
-            invoke: {
-                src: 'savePublishService',
-                input: ({ context }) => ({ context }),
-            },
-            meta: {
-                displayText: 'Saving publish service',
-            },
-            tags: ['publishing'],
-        },
-    },
-});
-const globalService = createActor(globalMachine, {
-    input: {},
-    // inspect,
-    inspect: (inspEvent) => {
-        eventEmitter.emit('inspect.globalService', inspEvent);
-        // console.log('[sdk] [service/index] inspEvent', inspEvent)
-        // eventEmitter.emit('globalService', inspEvent)
-        // let eventType: string = inspEvent.type
-        // if (inspEvent.event && inspEvent.event.type) {
-        //   eventType = inspEvent.event.type
-        // }
-        //
-        // if (typeof eventType === 'object') {
-        //   eventType = JSON.stringify(eventType)
-        // }
-        //
-        // let srcId = inspEvent.actorRef.id
-        //
-        // if (!srcId.includes('seedSdk')) {
-        //   srcId = inspEvent.actorRef.logic.config.id
-        // }
-        //
-        // if (inspEvent.type === '@xstate.snapshot') {
-        //   if (
-        //     inspEvent.event.type === CHILD_SNAPSHOT &&
-        //     inspEvent.snapshot &&
-        //     inspEvent.snapshot.machine.id === MachineIds.GLOBAL
-        //   ) {
-        //     return
-        //   }
-        //   if (inspEvent.snapshot && inspEvent.snapshot.value) {
-        //     if (typeof window !== 'undefined') {
-        //       eventEmitter.emit('globalService', {
-        //         type: eventType,
-        //         src: srcId,
-        //         snapshot: inspEvent.snapshot,
-        //       })
-        //     }
-        //   }
-        // } else {
-        //   if (typeof window !== 'undefined') {
-        //     let snapshot
-        //
-        //     try {
-        //       snapshot = inspEvent.actorRef.getSnapshot()
-        //     } catch (e) {
-        //       // This fails if the actor hasn't initialized yet, but that's OK I think
-        //       // console.log('[sdk] [service/index] ERROR', e)
-        //     }
-        //
-        //     eventEmitter.emit('globalService', {
-        //       type: eventType,
-        //       src: srcId,
-        //       snapshot,
-        //     })
-        //   }
-        // }
-    },
-});
-globalService.start();
-const getGlobalService = () => globalService;
-
-export { getGlobalService, globalMachine, globalService };
-//# sourceMappingURL=globalMachine.js.map

package/dist/src/services/global/globalMachine.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"globalMachine.js","sources":["../../../../../src/services/global/globalMachine.ts"],"sourcesContent":["import { ActorRefFrom, assign, createActor, raise, setup } from 'xstate'\nimport { createBrowserInspector } from '@statelyai/inspect'\nimport {\n  GLOBAL_ADDING_MODELS_TO_DB_SUCCESS,\n  GLOBAL_INITIALIZING_CREATE_ALL_ITEMS_SERVICES,\n  GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY,\n  GLOBAL_INITIALIZING_SEND_CONFIG,\n  GlobalState,\n  MachineIds,\n} from '@/services/internal/constants'\nimport { GlobalMachineContext, ModelClassType } from '@/types'\nimport { eventEmitter } from '@/eventBus'\nimport { initialize } from '@/services/global/actors/initialize'\nimport { getSchemaForModel } from '@/services/global/actors/getSchemaForModel'\nimport { addModelsToDb } from '@/services/global/actors/addModelsToDb'\nimport { itemMachineAll } from '../allItems/itemMachineAll'\nimport { publishMachine } from '@/services/publish/publishMachine'\nimport { savePublishService } from '@/services/global/actors/savePublishService'\nimport { internalMachine } from '../internal/internalMachine'\n\nconst {\n  UNINITIALIZED,\n  INITIALIZING,\n  INITIALIZED,\n  PUBLISHING_ITEM,\n  ADDING_MODELS_TO_DB,\n} = GlobalState\n\nconst { inspect } = createBrowserInspector({\n  autoStart: false,\n})\n\nconst globalMachine = setup({\n  types: {\n    context: {} as GlobalMachineContext,\n    input: {} as GlobalMachineContext | undefined,\n  },\n  actors: {\n    initialize,\n    addModelsToDb,\n    getSchemaForModel,\n    savePublishService,\n  },\n}).createMachine({\n  id: MachineIds.GLOBAL,\n  initial: UNINITIALIZED,\n  context: ({ input }) => input as GlobalMachineContext,\n  on: {\n    publishItemRequest: `.${PUBLISHING_ITEM}`,\n    savePublishService: `.savingPublishService`,\n    restorePublishService: `.${PUBLISHING_ITEM}`,\n  },\n  states: {\n    [UNINITIALIZED]: {\n      on: {\n        init: {\n          target: INITIALIZING,\n          actions: [\n            assign({\n              isInitialized: false,\n              addedModelRecordsToDb: false,\n              models: ({ event }) => event.models,\n              endpoints: ({ event }) => event.endpoints,\n              filesDir: ({ event }) => event.filesDir,\n              internalService: ({ spawn, event }) => {\n                return spawn(internalMachine, {\n                  systemId: MachineIds.INTERNAL,\n                  input: {\n                    endpoints: event.endpoints,\n                    filesDir: event.filesDir,\n                    addresses: event.addresses,\n                    arweaveDomain: event.arweaveDomain,\n                  },\n                })\n              },\n            }),\n          ],\n        },\n      },\n      meta: {\n        displayText: 'Booting up',\n        percentComplete: 5,\n      },\n      tags: ['loading', 'startup'],\n    },\n    [INITIALIZING]: {\n      on: {\n        [GLOBAL_INITIALIZING_SEND_CONFIG]: {\n          actions: assign({\n            endpoints: ({ event }) => event.endpoints,\n            environment: ({ event }) => event.environment,\n            addresses: ({ event }) => event.addresses,\n            isInitialized: true,\n          }),\n        },\n        [GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY]: ADDING_MODELS_TO_DB,\n        [GLOBAL_INITIALIZING_CREATE_ALL_ITEMS_SERVICES]: {\n          actions: [\n            assign(({ event, spawn }) => {\n              const allItemsServices: Record<\n                string,\n                ActorRefFrom<typeof itemMachineAll>\n              > = {}\n              for (const [modelName, ModelClass] of Object.entries(\n                event.create,\n              )) {\n                const service = spawn(itemMachineAll, {\n                  systemId: modelName,\n                  input: {\n                    modelName,\n                    ModelClass,\n                    modelSchema: (ModelClass as ModelClassType)!.schema,\n                    items: [],\n                  },\n                })\n                allItemsServices[`${modelName}Service`] = service\n              }\n\n              for (const [modelName, snapshot] of Object.entries(\n                event.restore,\n              )) {\n                const service = createActor(itemMachineAll, {\n                  snapshot,\n                })\n                service.start()\n                allItemsServices[`${modelName}Service`] = service\n              }\n              return allItemsServices\n            }),\n            raise({ type: 'allItemsServicesCreated' }),\n          ],\n        },\n      },\n      invoke: {\n        src: 'initialize',\n        input: ({ event, context }) => ({ event, context }),\n        meta: {\n          displayText: 'Initializing Seed SDK',\n          percentComplete: 10,\n        },\n        tags: ['loading', 'startup'],\n      },\n    },\n    [ADDING_MODELS_TO_DB]: {\n      on: {\n        [GLOBAL_ADDING_MODELS_TO_DB_SUCCESS]: {\n          target: INITIALIZED,\n          actions: assign({\n            addedModelRecordsToDb: true,\n          }),\n        },\n      },\n      invoke: {\n        src: 'addModelsToDb',\n        input: ({ context }) => ({ context }),\n        meta: {\n          displayText: 'Adding models to database',\n        },\n        tags: ['loading', 'startup'],\n      },\n    },\n    [INITIALIZED]: {\n      // type: 'parallel',\n      // on: {\n      //   publishItemRequest: `.${PUBLISHING_ITEM}`,\n      // },\n      meta: {\n        displayText: 'Global service ready',\n        percentComplete: 40,\n      },\n      tags: ['loading', 'startup'],\n      // initial: PUBLISHING_ITEM,\n    },\n    [PUBLISHING_ITEM]: {\n      target: INITIALIZED,\n      entry: [\n        assign({\n          publishItemService: ({ spawn, event }) =>\n            spawn(publishMachine, {\n              id: 'publishService',\n              input: {\n                localId: event.seedLocalId,\n              },\n            }),\n        }),\n      ],\n      meta: {\n        displayText: 'Publishing item',\n      },\n      tags: ['publishing'],\n    },\n    savingPublishService: {\n      target: INITIALIZED,\n      on: {\n        savePublishServiceSuccess: INITIALIZED,\n      },\n      invoke: {\n        src: 'savePublishService',\n        input: ({ context }) => ({ context }),\n      },\n      meta: {\n        displayText: 'Saving publish service',\n      },\n      tags: ['publishing'],\n    },\n  },\n})\n\nconst globalService = createActor(globalMachine, {\n  input: {},\n  // inspect,\n  inspect: (inspEvent) => {\n    eventEmitter.emit('inspect.globalService', inspEvent)\n    // console.log('[sdk] [service/index] inspEvent', inspEvent)\n    // eventEmitter.emit('globalService', inspEvent)\n    // let eventType: string = inspEvent.type\n    // if (inspEvent.event && inspEvent.event.type) {\n    //   eventType = inspEvent.event.type\n    // }\n    //\n    // if (typeof eventType === 'object') {\n    //   eventType = JSON.stringify(eventType)\n    // }\n    //\n    // let srcId = inspEvent.actorRef.id\n    //\n    // if (!srcId.includes('seedSdk')) {\n    //   srcId = inspEvent.actorRef.logic.config.id\n    // }\n    //\n    // if (inspEvent.type === '@xstate.snapshot') {\n    //   if (\n    //     inspEvent.event.type === CHILD_SNAPSHOT &&\n    //     inspEvent.snapshot &&\n    //     inspEvent.snapshot.machine.id === MachineIds.GLOBAL\n    //   ) {\n    //     return\n    //   }\n    //   if (inspEvent.snapshot && inspEvent.snapshot.value) {\n    //     if (typeof window !== 'undefined') {\n    //       eventEmitter.emit('globalService', {\n    //         type: eventType,\n    //         src: srcId,\n    //         snapshot: inspEvent.snapshot,\n    //       })\n    //     }\n    //   }\n    // } else {\n    //   if (typeof window !== 'undefined') {\n    //     let snapshot\n    //\n    //     try {\n    //       snapshot = inspEvent.actorRef.getSnapshot()\n    //     } catch (e) {\n    //       // This fails if the actor hasn't initialized yet, but that's OK I think\n    //       // console.log('[sdk] [service/index] ERROR', e)\n    //     }\n    //\n    //     eventEmitter.emit('globalService', {\n    //       type: eventType,\n    //       src: srcId,\n    //       snapshot,\n    //     })\n    //   }\n    // }\n  },\n})\n\nglobalService.start()\n\nconst getGlobalService = (): ActorRefFrom<typeof globalMachine> => globalService\n\nexport { globalMachine, getGlobalService, globalService }\n"],"names":[],"mappings":"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"}

package/dist/src/services/internal/actors/configureFs.d.ts

@@ -1,4 +0,0 @@
-import { EventObject } from 'xstate';
-import { FromCallbackInput, InternalMachineContext } from '@/types';
-export declare const configureFs: import("xstate").CallbackActorLogic<EventObject, FromCallbackInput<InternalMachineContext>, EventObject>;
-//# sourceMappingURL=configureFs.d.ts.map

package/dist/src/services/internal/actors/configureFs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"configureFs.d.ts","sourceRoot":"","sources":["../../../../../src/services/internal/actors/configureFs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAgB,MAAM,QAAQ,CAAA;AASlD,OAAO,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAKnE,eAAO,MAAM,WAAW,0GAmFtB,CAAA"}

package/dist/src/services/internal/actors/configureFs.js

@@ -1,70 +0,0 @@
-import { fromCallback } from 'xstate';
-import { areFsListenersReady, isFsInitialized } from '../../../events/files/index.js';
-import { waitForEvent } from '../../../events/index.js';
-import { INTERNAL_CONFIGURING_FS_SUCCESS, BROWSER_FS_TOP_DIR, DB_WAITING_FOR_FILES_RECEIVED } from '../constants.js';
-import debug from 'debug';
-import { isBrowser } from '../../../helpers/environment.js';
-import { BaseFileManager } from '../../../helpers/FileManager/BaseFileManager.js';
-
-const logger = debug('seedSdk:internal:actors:configureFs');
-const configureFs = fromCallback(({ sendBack, input: { context } }) => {
-    const { endpoints, appDbService, filesDir, } = context;
-    logger('[internal/actors] [configureFs] Configuring FS');
-    const _configureFs = async () => {
-        logger('[internal/actors] [configureFs] calling _configureFs');
-        logger('[internal/actors] [configureFs] areFsListenersReady:', areFsListenersReady());
-        logger('[internal/actors] [configureFs] isFsInitialized:', isFsInitialized());
-        if (isBrowser()) {
-            await waitForEvent({
-                req: {
-                    eventLabel: 'fs.downloadAll.request',
-                    data: { endpoints },
-                },
-                res: {
-                    eventLabel: 'fs.downloadAll.success',
-                },
-            });
-        }
-        const journalPath = `${filesDir || BROWSER_FS_TOP_DIR}/db/meta/_journal.json`;
-        let journalExists = await BaseFileManager.pathExists(journalPath);
-        if (!journalExists) {
-            const fs = await BaseFileManager.getFs();
-            journalExists = fs.existsSync(journalPath);
-        }
-        if (journalExists) {
-            appDbService.send({ type: DB_WAITING_FOR_FILES_RECEIVED });
-            logger('[internal/actors] [configureFs] fs configured!');
-            return true;
-        }
-        sendBack({ type: 'shouldWaitForFiles' });
-        return false;
-        // return new Promise<void>((resolve) => {
-        //   const interval = setInterval(() => {
-        //     journalExistsSync = fs.existsSync(journalPath)
-        //     logger(
-        //       '[internal/actors] [configureFs] journalExistsSync:',
-        //       journalExistsSync,
-        //     )
-        //     if (journalExistsSync) {
-        //       service.send({ type: DB_WAITING_FOR_FILES_RECEIVED })
-        //       clearInterval(interval)
-        //       resolve()
-        //     }
-        //   }, 200)
-        // })
-    };
-    // Some of our dependencies use fs sync functions, which don't work with
-    // OPFS. ZenFS creates an async cache of all files so that the sync functions
-    // work, but we have to wait for it to be built. Otherwise things like
-    // drizzleMigrate will fail since they can't see the migration files yet.
-    _configureFs().then((fsConfigured) => {
-        if (fsConfigured) {
-            sendBack({ type: INTERNAL_CONFIGURING_FS_SUCCESS });
-        }
-        return;
-    });
-    return () => { };
-});
-
-export { configureFs };
-//# sourceMappingURL=configureFs.js.map

package/dist/src/services/internal/actors/configureFs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"configureFs.js","sources":["../../../../../../src/services/internal/actors/configureFs.ts"],"sourcesContent":["import { EventObject, fromCallback } from 'xstate'\nimport { areFsListenersReady, isFsInitialized } from '@/events/files'\nimport { waitForEvent } from '@/events'\nimport {\n  BROWSER_FS_TOP_DIR,\n  DB_WAITING_FOR_FILES_RECEIVED,\n  INTERNAL_CONFIGURING_FS_SUCCESS,\n} from '@/services/internal/constants'\nimport debug from 'debug'\nimport { FromCallbackInput, InternalMachineContext } from '@/types'\nimport { isBrowser } from '@/helpers/environment'\nimport { BaseFileManager } from '@/helpers/FileManager/BaseFileManager'\nconst logger = debug('seedSdk:internal:actors:configureFs')\n\nexport const configureFs = fromCallback<\n  EventObject,\n  FromCallbackInput<InternalMachineContext>\n>(({ sendBack, input: { context } }) => {\n  const { endpoints, appDbService, filesDir, } = context\n\n  logger('[internal/actors] [configureFs] Configuring FS')\n\n  const _configureFs = async (): Promise<boolean> => {\n    logger('[internal/actors] [configureFs] calling _configureFs')\n\n    logger(\n      '[internal/actors] [configureFs] areFsListenersReady:',\n      areFsListenersReady(),\n    )\n    logger(\n      '[internal/actors] [configureFs] isFsInitialized:',\n      isFsInitialized(),\n    )\n\n    if (isBrowser()) {\n      await waitForEvent({\n        req: {\n          eventLabel: 'fs.downloadAll.request',\n          data: { endpoints },\n        },\n        res: {\n          eventLabel: 'fs.downloadAll.success',\n        },\n      })\n    }\n\n\n    const journalPath = `${filesDir || BROWSER_FS_TOP_DIR}/db/meta/_journal.json`\n\n\n    let journalExists = await BaseFileManager.pathExists(journalPath)\n\n    if (!journalExists) {\n      const fs = await BaseFileManager.getFs()\n      journalExists = fs.existsSync(journalPath)\n    }\n\n    if (journalExists) {\n      appDbService.send({ type: DB_WAITING_FOR_FILES_RECEIVED })\n      logger('[internal/actors] [configureFs] fs configured!')\n      return true\n    }\n\n    sendBack({ type: 'shouldWaitForFiles' })\n    \n\n    return false\n\n    // return new Promise<void>((resolve) => {\n    //   const interval = setInterval(() => {\n    //     journalExistsSync = fs.existsSync(journalPath)\n    //     logger(\n    //       '[internal/actors] [configureFs] journalExistsSync:',\n    //       journalExistsSync,\n    //     )\n    //     if (journalExistsSync) {\n    //       service.send({ type: DB_WAITING_FOR_FILES_RECEIVED })\n    //       clearInterval(interval)\n    //       resolve()\n    //     }\n    //   }, 200)\n    // })\n\n  }\n\n  // Some of our dependencies use fs sync functions, which don't work with\n  // OPFS. ZenFS creates an async cache of all files so that the sync functions\n  // work, but we have to wait for it to be built. Otherwise things like\n  // drizzleMigrate will fail since they can't see the migration files yet.\n  _configureFs().then((fsConfigured) => {\n    if (fsConfigured) {\n      sendBack({ type: INTERNAL_CONFIGURING_FS_SUCCESS })\n    }\n    return\n  })\n\n  return () => { }\n})\n"],"names":[],"mappings":";;;;;;;;AAYA,MAAM,MAAM,GAAG,KAAK,CAAC,qCAAqC,CAAC;AAEpD,MAAM,WAAW,GAAG,YAAY,CAGrC,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,EAAE,KAAI;IACrC,MAAM,EAAE,SAAS,EAAE,YAAY,EAAE,QAAQ,GAAG,GAAG,OAAO;IAEtD,MAAM,CAAC,gDAAgD,CAAC;AAExD,IAAA,MAAM,YAAY,GAAG,YAA6B;QAChD,MAAM,CAAC,sDAAsD,CAAC;AAE9D,QAAA,MAAM,CACJ,sDAAsD,EACtD,mBAAmB,EAAE,CACtB;AACD,QAAA,MAAM,CACJ,kDAAkD,EAClD,eAAe,EAAE,CAClB;QAED,IAAI,SAAS,EAAE,EAAE;AACf,YAAA,MAAM,YAAY,CAAC;AACjB,gBAAA,GAAG,EAAE;AACH,oBAAA,UAAU,EAAE,wBAAwB;oBACpC,IAAI,EAAE,EAAE,SAAS,EAAE;AACpB,iBAAA;AACD,gBAAA,GAAG,EAAE;AACH,oBAAA,UAAU,EAAE,wBAAwB;AACrC,iBAAA;AACF,aAAA,CAAC;QACJ;AAGA,QAAA,MAAM,WAAW,GAAG,CAAA,EAAG,QAAQ,IAAI,kBAAkB,wBAAwB;QAG7E,IAAI,aAAa,GAAG,MAAM,eAAe,CAAC,UAAU,CAAC,WAAW,CAAC;QAEjE,IAAI,CAAC,aAAa,EAAE;AAClB,YAAA,MAAM,EAAE,GAAG,MAAM,eAAe,CAAC,KAAK,EAAE;AACxC,YAAA,aAAa,GAAG,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC;QAC5C;QAEA,IAAI,aAAa,EAAE;YACjB,YAAY,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,6BAA6B,EAAE,CAAC;YAC1D,MAAM,CAAC,gDAAgD,CAAC;AACxD,YAAA,OAAO,IAAI;QACb;AAEA,QAAA,QAAQ,CAAC,EAAE,IAAI,EAAE,oBAAoB,EAAE,CAAC;AAGxC,QAAA,OAAO,KAAK;;;;;;;;;;;;;;;AAiBd,IAAA,CAAC;;;;;AAMD,IAAA,YAAY,EAAE,CAAC,IAAI,CAAC,CAAC,YAAY,KAAI;QACnC,IAAI,YAAY,EAAE;AAChB,YAAA,QAAQ,CAAC,EAAE,IAAI,EAAE,+BAA+B,EAAE,CAAC;QACrD;QACA;AACF,IAAA,CAAC,CAAC;AAEF,IAAA,OAAO,MAAK,EAAG,CAAC;AAClB,CAAC;;;;"}

package/dist/src/services/internal/actors/loadAppDb.d.ts

@@ -1,4 +0,0 @@
-import { EventObject } from 'xstate';
-import { FromCallbackInput, InternalMachineContext } from '@/types';
-export declare const loadAppDb: import("xstate").CallbackActorLogic<EventObject, FromCallbackInput<InternalMachineContext>, EventObject>;
-//# sourceMappingURL=loadAppDb.d.ts.map

package/dist/src/services/internal/actors/loadAppDb.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"loadAppDb.d.ts","sourceRoot":"","sources":["../../../../../src/services/internal/actors/loadAppDb.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAuC,MAAM,QAAQ,CAAA;AAOzE,OAAO,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAInE,eAAO,MAAM,SAAS,0GAwBpB,CAAA"}

package/dist/src/services/internal/actors/loadAppDb.js

@@ -1,22 +0,0 @@
-import { fromCallback, waitFor } from 'xstate';
-import { INTERNAL_LOADING_APP_DB_SUCCESS, DB_NAME_APP, DB_ON_SNAPSHOT } from '../constants.js';
-import debug from 'debug';
-
-debug('seedSdk:services:internal:actors:loadAppDb');
-const loadAppDb = fromCallback(({ sendBack, input: { context } }) => {
-    const { appDbService } = context;
-    const _loadAppDb = async () => {
-        await waitFor(appDbService, (snapshot) => {
-            return snapshot.value === 'ready';
-        });
-        sendBack({ type: DB_ON_SNAPSHOT, dbName: DB_NAME_APP, snapshot: appDbService.getSnapshot() });
-    };
-    _loadAppDb().then(() => {
-        sendBack({ type: INTERNAL_LOADING_APP_DB_SUCCESS });
-    });
-    return () => {
-    };
-});
-
-export { loadAppDb };
-//# sourceMappingURL=loadAppDb.js.map

package/dist/src/services/internal/actors/loadAppDb.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"loadAppDb.js","sources":["../../../../../../src/services/internal/actors/loadAppDb.ts"],"sourcesContent":["import { EventObject, fromCallback, Subscription, waitFor } from 'xstate'\nimport {\n  DB_NAME_APP,\n  DB_ON_SNAPSHOT,\n  INTERNAL_LOADING_APP_DB_SUCCESS,\n} from '@/services/internal/constants'\nimport debug from 'debug'\nimport { FromCallbackInput, InternalMachineContext } from '@/types'\n\nconst logger = debug('seedSdk:services:internal:actors:loadAppDb')\n\nexport const loadAppDb = fromCallback<\n  EventObject,\n  FromCallbackInput<InternalMachineContext>\n>(({ sendBack, input: { context } }) => {\n  const { appDbService } = context\n\n  let subscription: Subscription | undefined\n\n  const _loadAppDb = async (): Promise<void> => {\n    await waitFor(appDbService, (snapshot) => {\n      return snapshot.value === 'ready'\n    })\n    sendBack({ type: DB_ON_SNAPSHOT, dbName: DB_NAME_APP, snapshot: appDbService.getSnapshot() })\n  }\n\n  _loadAppDb().then(() => {\n    sendBack({ type: INTERNAL_LOADING_APP_DB_SUCCESS })\n  })\n\n  return () => {\n    if (subscription) {\n      subscription.unsubscribe()\n    }\n  }\n})\n"],"names":[],"mappings":";;;;AASe,KAAK,CAAC,4CAA4C;AAE1D,MAAM,SAAS,GAAG,YAAY,CAGnC,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,EAAE,KAAI;AACrC,IAAA,MAAM,EAAE,YAAY,EAAE,GAAG,OAAO;AAIhC,IAAA,MAAM,UAAU,GAAG,YAA0B;AAC3C,QAAA,MAAM,OAAO,CAAC,YAAY,EAAE,CAAC,QAAQ,KAAI;AACvC,YAAA,OAAO,QAAQ,CAAC,KAAK,KAAK,OAAO;AACnC,QAAA,CAAC,CAAC;AACF,QAAA,QAAQ,CAAC,EAAE,IAAI,EAAE,cAAc,EAAE,MAAM,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,CAAC,WAAW,EAAE,EAAE,CAAC;AAC/F,IAAA,CAAC;AAED,IAAA,UAAU,EAAE,CAAC,IAAI,CAAC,MAAK;AACrB,QAAA,QAAQ,CAAC,EAAE,IAAI,EAAE,+BAA+B,EAAE,CAAC;AACrD,IAAA,CAAC,CAAC;AAEF,IAAA,OAAO,MAAK;AAIZ,IAAA,CAAC;AACH,CAAC;;;;"}

package/dist/src/services/internal/actors/prepareDb.d.ts

@@ -1,5 +0,0 @@
-import { InternalMachineContext } from '@/types';
-import { FromCallbackInput } from '@/types';
-import { EventObject } from 'xstate';
-export declare const prepareDb: import("xstate").CallbackActorLogic<EventObject, FromCallbackInput<InternalMachineContext>, EventObject>;
-//# sourceMappingURL=prepareDb.d.ts.map

package/dist/src/services/internal/actors/prepareDb.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prepareDb.d.ts","sourceRoot":"","sources":["../../../../../src/services/internal/actors/prepareDb.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAChD,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAC3C,OAAO,EAAE,WAAW,EAAgB,MAAM,QAAQ,CAAA;AAGlD,eAAO,MAAM,SAAS,0GAuBpB,CAAA"}

package/dist/src/services/internal/actors/saveConfig.d.ts

@@ -1,4 +0,0 @@
-import { EventObject } from 'xstate';
-import { FromCallbackInput, InternalMachineContext } from '@/types';
-export declare const saveConfig: import("xstate").CallbackActorLogic<EventObject, FromCallbackInput<InternalMachineContext>, EventObject>;
-//# sourceMappingURL=saveConfig.d.ts.map

package/dist/src/services/internal/actors/saveConfig.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"saveConfig.d.ts","sourceRoot":"","sources":["../../../../../src/services/internal/actors/saveConfig.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAgB,MAAM,QAAQ,CAAA;AAGlD,OAAO,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAMnE,eAAO,MAAM,UAAU,0GAuErB,CAAA"}

package/dist/src/services/internal/actors/saveConfig.js

@@ -1,76 +0,0 @@
-import { fromCallback } from 'xstate';
-import { INTERNAL_SAVING_CONFIG_SUCCESS } from '../constants.js';
-import { BaseDb } from '../../../db/Db/BaseDb.js';
-import '../../../seedSchema/SeedSchema.js';
-import '../../../seedSchema/VersionSchema.js';
-import '../../../seedSchema/MetadataSchema.js';
-import { appState } from '../../../seedSchema/AppStateSchema.js';
-import '../../../seedSchema/ModelSchema.js';
-import '../../../seedSchema/ModelUidSchema.js';
-import '../../../seedSchema/PropertyUidSchema.js';
-import '../../../seedSchema/ConfigSchema.js';
-import debug from 'debug';
-
-const logger = debug('seedSdk:services:internal:actors:saveConfig');
-const saveConfig = fromCallback(({ sendBack, input: { context } }) => {
-    logger('saveConfig starting');
-    const { endpoints, addresses, arweaveDomain } = context;
-    if (!endpoints) {
-        throw new Error('saveConfig called with invalid endpoints');
-    }
-    const _saveConfig = async () => {
-        const appDb = BaseDb.getAppDb();
-        if (!appDb) {
-            throw new Error('App DB not found');
-        }
-        const endpointsValueString = JSON.stringify(endpoints);
-        const addressesValueString = JSON.stringify(addresses);
-        // TODO: Figure out how to define on conflict with multiple rows added
-        await appDb
-            .insert(appState)
-            .values({
-            key: 'endpoints',
-            value: endpointsValueString,
-        })
-            .onConflictDoUpdate({
-            target: appState.key,
-            set: {
-                value: endpointsValueString,
-            },
-        });
-        if (addresses) {
-            await appDb
-                .insert(appState)
-                .values({
-                key: 'addresses',
-                value: addressesValueString,
-            })
-                .onConflictDoUpdate({
-                target: appState.key,
-                set: {
-                    value: addressesValueString,
-                },
-            });
-        }
-        await appDb
-            .insert(appState)
-            .values({
-            key: 'arweaveDomain',
-            value: arweaveDomain || 'arweave.net',
-        })
-            .onConflictDoUpdate({
-            target: appState.key,
-            set: {
-                value: arweaveDomain || 'arweave.net',
-            },
-        });
-    };
-    _saveConfig().then(() => {
-        logger('saveConfig success');
-        return sendBack({ type: INTERNAL_SAVING_CONFIG_SUCCESS });
-    });
-    return () => { };
-});
-
-export { saveConfig };
-//# sourceMappingURL=saveConfig.js.map

package/dist/src/services/internal/actors/saveConfig.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"saveConfig.js","sources":["../../../../../../src/services/internal/actors/saveConfig.ts"],"sourcesContent":["import { EventObject, fromCallback } from 'xstate'\nimport { INTERNAL_SAVING_CONFIG_SUCCESS } from '@/services/internal/constants'\nimport { BaseDb } from '@/db/Db/BaseDb'\nimport { FromCallbackInput, InternalMachineContext } from '@/types'\nimport { appState } from '@/seedSchema'\nimport debug                    from 'debug'\n\nconst logger = debug('seedSdk:services:internal:actors:saveConfig')\n\nexport const saveConfig = fromCallback<\n  EventObject,\n  FromCallbackInput<InternalMachineContext>\n>(({ sendBack, input: { context } }) => {\n\n  logger('saveConfig starting')\n\n  const { endpoints, addresses, arweaveDomain } = context\n\n  if (!endpoints) {\n    throw new Error('saveConfig called with invalid endpoints')\n  }\n\n  const _saveConfig = async (): Promise<void> => {\n    const appDb = BaseDb.getAppDb()\n\n    if (!appDb) {\n      throw new Error('App DB not found')\n    }\n    const endpointsValueString = JSON.stringify(endpoints)\n    const addressesValueString = JSON.stringify(addresses)\n\n    // TODO: Figure out how to define on conflict with multiple rows added\n    await appDb\n      .insert(appState)\n      .values({\n        key: 'endpoints',\n        value: endpointsValueString,\n      })\n      .onConflictDoUpdate({\n        target: appState.key,\n        set: {\n        value: endpointsValueString,\n        },\n      })\n\n    if (addresses) {\n      await appDb\n        .insert(appState)\n      .values({\n        key: 'addresses',\n        value: addressesValueString,\n      })\n      .onConflictDoUpdate({\n        target: appState.key,\n        set: {\n          value: addressesValueString,\n        },\n      })\n    }\n\n    await appDb\n      .insert(appState)\n      .values({\n        key: 'arweaveDomain',\n        value: arweaveDomain || 'arweave.net',\n      })\n      .onConflictDoUpdate({\n        target: appState.key,\n        set: {\n          value: arweaveDomain || 'arweave.net',\n        },\n      })\n    }\n\n  _saveConfig().then(() => {\n    logger('saveConfig success')\n    return sendBack({ type: INTERNAL_SAVING_CONFIG_SUCCESS })\n  })\n\n  return () => { }\n})\n"],"names":[],"mappings":";;;;;;;;;;;;;AAOA,MAAM,MAAM,GAAG,KAAK,CAAC,6CAA6C,CAAC;AAE5D,MAAM,UAAU,GAAG,YAAY,CAGpC,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,EAAE,KAAI;IAErC,MAAM,CAAC,qBAAqB,CAAC;IAE7B,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,aAAa,EAAE,GAAG,OAAO;IAEvD,IAAI,CAAC,SAAS,EAAE;AACd,QAAA,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC;IAC7D;AAEA,IAAA,MAAM,WAAW,GAAG,YAA0B;AAC5C,QAAA,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,EAAE;QAE/B,IAAI,CAAC,KAAK,EAAE;AACV,YAAA,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC;QACrC;QACA,MAAM,oBAAoB,GAAG,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC;QACtD,MAAM,oBAAoB,GAAG,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC;;AAGtD,QAAA,MAAM;aACH,MAAM,CAAC,QAAQ;AACf,aAAA,MAAM,CAAC;AACN,YAAA,GAAG,EAAE,WAAW;AAChB,YAAA,KAAK,EAAE,oBAAoB;SAC5B;AACA,aAAA,kBAAkB,CAAC;YAClB,MAAM,EAAE,QAAQ,CAAC,GAAG;AACpB,YAAA,GAAG,EAAE;AACL,gBAAA,KAAK,EAAE,oBAAoB;AAC1B,aAAA;AACF,SAAA,CAAC;QAEJ,IAAI,SAAS,EAAE;AACb,YAAA,MAAM;iBACH,MAAM,CAAC,QAAQ;AACjB,iBAAA,MAAM,CAAC;AACN,gBAAA,GAAG,EAAE,WAAW;AAChB,gBAAA,KAAK,EAAE,oBAAoB;aAC5B;AACA,iBAAA,kBAAkB,CAAC;gBAClB,MAAM,EAAE,QAAQ,CAAC,GAAG;AACpB,gBAAA,GAAG,EAAE;AACH,oBAAA,KAAK,EAAE,oBAAoB;AAC5B,iBAAA;AACF,aAAA,CAAC;QACJ;AAEA,QAAA,MAAM;aACH,MAAM,CAAC,QAAQ;AACf,aAAA,MAAM,CAAC;AACN,YAAA,GAAG,EAAE,eAAe;YACpB,KAAK,EAAE,aAAa,IAAI,aAAa;SACtC;AACA,aAAA,kBAAkB,CAAC;YAClB,MAAM,EAAE,QAAQ,CAAC,GAAG;AACpB,YAAA,GAAG,EAAE;gBACH,KAAK,EAAE,aAAa,IAAI,aAAa;AACtC,aAAA;AACF,SAAA,CAAC;AACJ,IAAA,CAAC;AAEH,IAAA,WAAW,EAAE,CAAC,IAAI,CAAC,MAAK;QACtB,MAAM,CAAC,oBAAoB,CAAC;QAC5B,OAAO,QAAQ,CAAC,EAAE,IAAI,EAAE,8BAA8B,EAAE,CAAC;AAC3D,IAAA,CAAC,CAAC;AAEF,IAAA,OAAO,MAAK,EAAG,CAAC;AAClB,CAAC;;;;"}

package/dist/src/services/internal/actors/validateInput.d.ts

@@ -1,4 +0,0 @@
-import { EventObject } from 'xstate';
-import { FromCallbackInput, InternalMachineContext } from '@/types';
-export declare const validateInput: import("xstate").CallbackActorLogic<EventObject, FromCallbackInput<InternalMachineContext>, EventObject>;
-//# sourceMappingURL=validateInput.d.ts.map

package/dist/src/services/internal/actors/validateInput.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"validateInput.d.ts","sourceRoot":"","sources":["../../../../../src/services/internal/actors/validateInput.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAgB,MAAM,QAAQ,CAAA;AAElD,OAAO,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAGnE,eAAO,MAAM,aAAa,0GAqCzB,CAAA"}

package/dist/src/services/internal/actors/validateInput.js

@@ -1,34 +0,0 @@
-import { fromCallback } from 'xstate';
-import { ARWEAVE_HOST, INTERNAL_VALIDATING_INPUT_SUCCESS } from '../constants.js';
-import { isBrowser } from '../../../helpers/environment.js';
-
-const validateInput = fromCallback(({ sendBack, input: { context } }) => {
-    const { endpoints, addresses, arweaveDomain } = context;
-    let { filesDir } = context;
-    if (!endpoints || !endpoints.filePaths || !endpoints.files) {
-        throw new Error('validateInput called with invalid endpoints');
-    }
-    if (!filesDir) {
-        if (isBrowser()) {
-            filesDir = '/';
-        }
-        if (!isBrowser()) {
-            throw new Error('validateInput called with invalid filesDir');
-        }
-    }
-    const _validateInput = async () => {
-        sendBack({
-            type: INTERNAL_VALIDATING_INPUT_SUCCESS,
-            endpoints,
-            addresses,
-            filesDir,
-            arweaveDomain: arweaveDomain || ARWEAVE_HOST,
-        });
-    };
-    _validateInput().then(() => {
-        return;
-    });
-});
-
-export { validateInput };
-//# sourceMappingURL=validateInput.js.map

package/dist/src/services/internal/actors/validateInput.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"validateInput.js","sources":["../../../../../../src/services/internal/actors/validateInput.ts"],"sourcesContent":["import { EventObject, fromCallback } from 'xstate'\nimport { INTERNAL_VALIDATING_INPUT_SUCCESS, ARWEAVE_HOST } from '@/services/internal/constants'\nimport { FromCallbackInput, InternalMachineContext } from '@/types'\nimport { isBrowser, isNode } from '@/helpers/environment'\n\nexport const validateInput = fromCallback<\n  EventObject,\n  FromCallbackInput<InternalMachineContext>\n>(\n  ({ sendBack, input: { context } }) => {\n\n    const { endpoints, addresses, arweaveDomain } = context\n    let { filesDir } = context\n\n    if (!endpoints || !endpoints.filePaths || !endpoints.files) {\n      throw new Error('validateInput called with invalid endpoints')\n    }\n\n    if (!filesDir) {\n      if (isBrowser()) {\n        filesDir = '/'\n      }\n\n      if (!isBrowser()) {\n        throw new Error('validateInput called with invalid filesDir')\n      }\n    }\n\n    const _validateInput = async (): Promise<void> => {\n      sendBack({\n        type: INTERNAL_VALIDATING_INPUT_SUCCESS,\n        endpoints,\n        addresses,\n        filesDir,\n        arweaveDomain: arweaveDomain || ARWEAVE_HOST,\n      })\n    }\n\n    _validateInput().then(() => {\n      return\n    })\n  },\n)\n"],"names":[],"mappings":";;;;AAKO,MAAM,aAAa,GAAG,YAAY,CAIvC,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,EAAE,KAAI;IAEnC,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,aAAa,EAAE,GAAG,OAAO;AACvD,IAAA,IAAI,EAAE,QAAQ,EAAE,GAAG,OAAO;AAE1B,IAAA,IAAI,CAAC,SAAS,IAAI,CAAC,SAAS,CAAC,SAAS,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE;AAC1D,QAAA,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC;IAChE;IAEA,IAAI,CAAC,QAAQ,EAAE;QACb,IAAI,SAAS,EAAE,EAAE;YACf,QAAQ,GAAG,GAAG;QAChB;AAEA,QAAA,IAAI,CAAC,SAAS,EAAE,EAAE;AAChB,YAAA,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC;QAC/D;IACF;AAEA,IAAA,MAAM,cAAc,GAAG,YAA0B;AAC/C,QAAA,QAAQ,CAAC;AACP,YAAA,IAAI,EAAE,iCAAiC;YACvC,SAAS;YACT,SAAS;YACT,QAAQ;YACR,aAAa,EAAE,aAAa,IAAI,YAAY;AAC7C,SAAA,CAAC;AACJ,IAAA,CAAC;AAED,IAAA,cAAc,EAAE,CAAC,IAAI,CAAC,MAAK;QACzB;AACF,IAAA,CAAC,CAAC;AACJ,CAAC;;;;"}

package/dist/src/services/internal/actors/waitForFiles.d.ts

@@ -1,4 +0,0 @@
-import { EventObject } from 'xstate';
-import { FromCallbackInput, InternalMachineContext } from '@/types';
-export declare const waitForFiles: import("xstate").CallbackActorLogic<EventObject, FromCallbackInput<InternalMachineContext>, EventObject>;
-//# sourceMappingURL=waitForFiles.d.ts.map

package/dist/src/services/internal/actors/waitForFiles.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"waitForFiles.d.ts","sourceRoot":"","sources":["../../../../../src/services/internal/actors/waitForFiles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAgB,MAAM,QAAQ,CAAA;AAClD,OAAO,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAOnE,eAAO,MAAM,YAAY,0GAgCvB,CAAA"}

package/dist/src/services/internal/actors/waitForFiles.js

@@ -1,33 +0,0 @@
-import { fromCallback } from 'xstate';
-import debug from 'debug';
-import { isBrowser } from '../../../helpers/environment.js';
-import '../../../helpers/index.js';
-import { BaseFileManager } from '../../../helpers/FileManager/BaseFileManager.js';
-
-debug('seedSdk:services:internal:actors:waitForFiles');
-const waitForFiles = fromCallback(({ sendBack, input: { context } }) => {
-    if (!isBrowser()) {
-        sendBack({ type: 'filesReceived' });
-        return;
-    }
-    const { endpoints } = context;
-    const filesDir = endpoints.files;
-    const _waitForFiles = async () => {
-        return new Promise((resolve) => {
-            const interval = setInterval(async () => {
-                const journalExists = await BaseFileManager.pathExists(`${filesDir}/db/meta/_journal.json`);
-                if (journalExists) {
-                    clearInterval(interval);
-                    resolve();
-                }
-            }, 1000);
-        });
-    };
-    _waitForFiles().then(() => {
-        sendBack({ type: 'filesReceived' });
-        return;
-    });
-});
-
-export { waitForFiles };
-//# sourceMappingURL=waitForFiles.js.map

package/dist/src/services/internal/actors/waitForFiles.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"waitForFiles.js","sources":["../../../../../../src/services/internal/actors/waitForFiles.ts"],"sourcesContent":["import { EventObject, fromCallback } from 'xstate'\nimport { FromCallbackInput, InternalMachineContext } from '@/types'\nimport debug from 'debug'\nimport { isBrowser } from '@/helpers/environment'\nimport { BaseFileManager } from '@/helpers'\n\nconst logger = debug('seedSdk:services:internal:actors:waitForFiles')\n\nexport const waitForFiles = fromCallback<\n  EventObject,\n  FromCallbackInput<InternalMachineContext>\n>(({ sendBack, input: { context } }) => {\n\n  if (!isBrowser()) {\n    sendBack({ type: 'filesReceived' })\n    return\n  }\n\n  const { endpoints } = context\n\n  const filesDir = endpoints.files\n\n  const _waitForFiles = async (): Promise<void> => {\n    return new Promise((resolve) => {\n      const interval = setInterval(async () => {\n        const journalExists = await BaseFileManager.pathExists(\n          `${filesDir}/db/meta/_journal.json`,\n        )\n        if (journalExists) {\n          clearInterval(interval)\n          resolve()\n        }\n      }, 1000)\n    })\n  }\n\n  _waitForFiles().then(() => {\n    sendBack({ type: 'filesReceived' })\n    return\n  })\n})\n"],"names":[],"mappings":";;;;;;AAMe,KAAK,CAAC,+CAA+C;AAE7D,MAAM,YAAY,GAAG,YAAY,CAGtC,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,EAAE,KAAI;AAErC,IAAA,IAAI,CAAC,SAAS,EAAE,EAAE;AAChB,QAAA,QAAQ,CAAC,EAAE,IAAI,EAAE,eAAe,EAAE,CAAC;QACnC;IACF;AAEA,IAAA,MAAM,EAAE,SAAS,EAAE,GAAG,OAAO;AAE7B,IAAA,MAAM,QAAQ,GAAG,SAAS,CAAC,KAAK;AAEhC,IAAA,MAAM,aAAa,GAAG,YAA0B;AAC9C,QAAA,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,KAAI;AAC7B,YAAA,MAAM,QAAQ,GAAG,WAAW,CAAC,YAAW;gBACtC,MAAM,aAAa,GAAG,MAAM,eAAe,CAAC,UAAU,CACpD,CAAA,EAAG,QAAQ,CAAA,sBAAA,CAAwB,CACpC;gBACD,IAAI,aAAa,EAAE;oBACjB,aAAa,CAAC,QAAQ,CAAC;AACvB,oBAAA,OAAO,EAAE;gBACX;YACF,CAAC,EAAE,IAAI,CAAC;AACV,QAAA,CAAC,CAAC;AACJ,IAAA,CAAC;AAED,IAAA,aAAa,EAAE,CAAC,IAAI,CAAC,MAAK;AACxB,QAAA,QAAQ,CAAC,EAAE,IAAI,EAAE,eAAe,EAAE,CAAC;QACnC;AACF,IAAA,CAAC,CAAC;AACJ,CAAC;;;;"}