@seedprotocol/sdk 0.3.30 → 0.4.0

package/dist/src/types/model.d.ts

@@ -1,28 +1,25 @@
 import { PropertyStates, PropertyValue } from './property';
 import { Actor, AnyActorLogic } from 'xstate';
 import { Static } from '@sinclair/typebox';
-import { IModelClass, TModelSchema, TProperty } from '@/schema';
-import { BaseItem } from '@/Item/BaseItem';
+import { TModelSchema, TProperty } from '@/Schema';
+import { Item } from '@/Item/Item';
+import type { Model } from '@/Model/Model';
 export type ModelDefinitions = {
-    [modelName: string]: ModelClassType;
+    [modelName: string]: Model;
 };
 export type ModelStatus = (propName: string) => keyof PropertyStates;
 export type ExcludedKeys = 'states' | 'status';
-export type ModelClassType = {
-    originalConstructor: () => void;
+/**
+ * @deprecated Use Model directly instead. This type is kept for backward compatibility during migration.
+ */
+export type ModelClassType = Model;
+export type ModelValues<T extends Record<string, any>> = Item<any> & {
     schema: ModelSchema;
-    schemaUid?: string;
-    create: (values: ModelValues<any>) => Promise<BaseItem<any>>;
-};
-export type ModelValues<T extends Record<string, any>> = BaseItem<any> & {
-    schema: ModelSchema;
-    ModelClass?: ModelClassType;
-    [key: string & keyof T]: PropertyValue;
+    ModelClass?: Model;
+} & {
+    [K in keyof T]: PropertyValue;
 };
 export type StatesMap<T> = Map<string, Actor<T extends AnyActorLogic ? T : never>>;
 export type ModelSchema = Partial<Static<typeof TModelSchema>>;
-export type ModelConstructor = <T extends {
-    new (...args: any[]): IModelClass;
-}>(constructor: T) => T & IModelClass;
 export type ModelProperty = typeof TProperty;
 //# sourceMappingURL=model.d.ts.map

package/dist/src/types/model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../../src/types/model.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAC1D,OAAO,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAA;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAoC,mBAAmB,CAAA;AACxE,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAC/D,OAAO,EAAE,QAAQ,EAAE,MAAkC,iBAAiB,CAAA;AAEtE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,CAAC,SAAS,EAAE,MAAM,GAAG,cAAc,CAAA;CACpC,CAAA;AAED,MAAM,MAAM,WAAW,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,cAAc,CAAA;AAEpE,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,QAAQ,CAAA;AAM9C,MAAM,MAAM,cAAc,GAAG;IAC3B,mBAAmB,EAAE,MAAM,IAAI,CAAA;IAC/B,MAAM,EAAE,WAAW,CAAA;IACnB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,CAAC,KAAK,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAA;CAC7D,CAAA;AAED,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,QAAQ,CAAC,GAAG,CAAC,GAAG;IACvE,MAAM,EAAE,WAAW,CAAA;IACnB,UAAU,CAAC,EAAE,cAAc,CAAA;IAC3B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG,aAAa,CAAA;CACvC,CAAA;AAED,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,SAAS,aAAa,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC,CAAA;AAMlF,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,OAAO,YAAY,CAAC,CAAC,CAAA;AAE9D,MAAM,MAAM,gBAAgB,GAAG,CAC7B,CAAC,SAAS;IAAE,KAAI,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,WAAW,CAAA;CAAE,EAE9C,WAAW,EAAE,CAAC,KACX,CAAC,GAAG,WAAW,CAAA;AAIpB,MAAM,MAAM,aAAa,GAAG,OAAO,SAAS,CAAA"}
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../../src/types/model.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAC1D,OAAO,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAA;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAoC,mBAAmB,CAAA;AACxE,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAClD,OAAO,EAAE,IAAI,EAAE,MAAkC,aAAa,CAAA;AAC9D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAA;AAE1C,MAAM,MAAM,gBAAgB,GAAG;IAC7B,CAAC,SAAS,EAAE,MAAM,GAAG,KAAK,CAAA;CAC3B,CAAA;AAED,MAAM,MAAM,WAAW,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,cAAc,CAAA;AAEpE,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,QAAQ,CAAA;AAM9C;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,KAAK,CAAA;AAElC,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG;IACnE,MAAM,EAAE,WAAW,CAAA;IACnB,UAAU,CAAC,EAAE,KAAK,CAAA;CACnB,GAAG;KACD,CAAC,IAAI,MAAM,CAAC,GAAG,aAAa;CAC9B,CAAA;AAED,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,SAAS,aAAa,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC,CAAA;AAMlF,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,OAAO,YAAY,CAAC,CAAC,CAAA;AAI9D,MAAM,MAAM,aAAa,GAAG,OAAO,SAAS,CAAA"}

package/dist/src/types/property.d.ts

@@ -1,5 +1,5 @@
 import { Static } from '@sinclair/typebox';
-import { TProperty, TPropertyDataType, TPropertyDefs, TStorageType } from '@/schema';
+import { TProperty, TPropertyDataType, TPropertyDefs, TStorageType } from '@/Schema';
 import { MetadataType } from '@/seedSchema';
 export type PropertyDataType = Static<typeof TPropertyDataType>;
 export type StorageType = Static<typeof TStorageType>;

package/dist/src/vite/index.d.ts

@@ -0,0 +1,47 @@
+import type { Plugin } from 'vite';
+export interface SeedVitePluginOptions {
+    /**
+     * Custom ZenFS configuration to apply on initialization
+     */
+    zenfsConfig?: Record<string, unknown>;
+    /**
+     * Additional modules to alias to ZenFS equivalents
+     * @default ['fs', 'fs/promises', 'node:fs', 'node:fs/promises']
+     */
+    fsModules?: string[];
+    /**
+     * Whether to inject automatic ZenFS initialization
+     * @default true
+     */
+    autoInit?: boolean;
+    /**
+     * Enable debug logging
+     * @default false
+     */
+    debug?: boolean;
+    /**
+     * Entry points to scan for dependencies during initial optimization.
+     * This helps prevent incremental dependency discovery and multiple reloads.
+     * Can be file paths or glob patterns relative to the project root.
+     * If not provided, the plugin will attempt to auto-detect SDK entry points.
+     */
+    entryPoints?: string[];
+    /**
+     * Whether to automatically include common SDK dependencies in optimizeDeps.include.
+     * Set to false if these dependencies are not installed in your project.
+     * @default false
+     */
+    autoIncludeDeps?: boolean;
+}
+export declare function seedVitePlugin(options?: SeedVitePluginOptions): Plugin[];
+/**
+ * Helper to ensure ZenFS is ready before using fs operations
+ */
+export declare function waitForFs(): Promise<void>;
+declare global {
+    interface Window {
+        __seedFsReady?: Promise<void>;
+    }
+}
+export default seedVitePlugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/vite/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/vite/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAkB,MAAM,MAAM,CAAA;AAMlD,MAAM,WAAW,qBAAqB;IACpC;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAErC;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,EAAE,CAAA;IAEpB;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;IAElB;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAA;IAEf;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;IAEtB;;;;OAIG;IACH,eAAe,CAAC,EAAE,OAAO,CAAA;CAC1B;AAkDD,wBAAgB,cAAc,CAAC,OAAO,GAAE,qBAA0B,GAAG,MAAM,EAAE,CA+e5E;AAED;;GAEG;AACH,wBAAsB,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,CAI/C;AAGD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,aAAa,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,CAAA;KAC9B;CACF;AAED,eAAe,cAAc,CAAA"}

package/dist/stores/eas.js

@@ -0,0 +1,23 @@
+import { getSchemaUidBySchemaName } from '../eas.js';
+import { toSnakeCase } from '../helpers/index.js';
+import '../graphql/gql/graphql.js';
+
+const schemaUidForSchemaDefinition = new Map();
+const setSchemaUidForSchemaDefinition = ({ text, schemaUid }) => {
+    const propertySnakeCase = toSnakeCase(text);
+    schemaUidForSchemaDefinition.set(propertySnakeCase, schemaUid);
+};
+const getSchemaUidForSchemaDefinition = async ({ schemaText }) => {
+    const textSnakeCase = toSnakeCase(schemaText);
+    if (!schemaUidForSchemaDefinition.has(textSnakeCase)) {
+        const schemaUid = await getSchemaUidBySchemaName({ schemaName: textSnakeCase });
+        if (schemaUid) {
+            setSchemaUidForSchemaDefinition({ text: textSnakeCase, schemaUid });
+        }
+        return schemaUid;
+    }
+    return schemaUidForSchemaDefinition.get(textSnakeCase);
+};
+
+export { getSchemaUidForSchemaDefinition, setSchemaUidForSchemaDefinition };
+//# sourceMappingURL=eas.js.map

package/dist/stores/eas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"eas.js","sources":["../../../src/stores/eas.ts"],"sourcesContent":["import { getSchemaUidBySchemaName } from '@/eas'\nimport { toSnakeCase } from '@/helpers'\nimport { getSchemaForItemProperty } from '@/helpers/getSchemaForItemProperty'\n\nconst schemaUidForSchemaDefinition = new Map<string, string>()\n\ntype SetSchemaUidForSchemaDefinitionProps = {\n  text: string\n  schemaUid: string\n}\n\ntype SetSchemaUidForSchemaDefinition = (\n  props: SetSchemaUidForSchemaDefinitionProps,\n) => void\n\nexport const setSchemaUidForSchemaDefinition: SetSchemaUidForSchemaDefinition = ({ text, schemaUid }) => {\n  const propertySnakeCase = toSnakeCase(text)\n  schemaUidForSchemaDefinition.set(propertySnakeCase, schemaUid)\n}\n\ntype GetSchemaUidForSchemaDefinitionProps = {\n  schemaText: string\n}\n\ntype GetSchemaUidForSchemaDefinition = (\n  props: GetSchemaUidForSchemaDefinitionProps,\n) => Promise<string | undefined>\n\nexport const getSchemaUidForSchemaDefinition: GetSchemaUidForSchemaDefinition = async ({ schemaText }) => {\n  const textSnakeCase = toSnakeCase(schemaText)\n  if (!schemaUidForSchemaDefinition.has(textSnakeCase)) {\n    const schemaUid = await getSchemaUidBySchemaName({ schemaName: textSnakeCase })\n    if (schemaUid) {\n      setSchemaUidForSchemaDefinition({ text: textSnakeCase, schemaUid })\n    }\n    return schemaUid\n  }\n  return schemaUidForSchemaDefinition.get(textSnakeCase)\n}\n\nexport const fetchSchemaUids = async () => {\n  const versionSchema = await getSchemaForItemProperty({\n    propertyName: 'version',\n    easDataType: 'bytes32',\n  })\n  if (versionSchema) {\n    setSchemaUidForSchemaDefinition({\n      text: 'version',\n      schemaUid: versionSchema.id,\n    })\n  }\n  const imageSchema = await getSchemaForItemProperty({\n    propertyName: 'image',\n    easDataType: 'bytes32',\n  })\n  if (imageSchema) {\n    setSchemaUidForSchemaDefinition({\n      text: 'image',\n      schemaUid: imageSchema.id,\n    })\n  }\n}\n"],"names":[],"mappings":";;;;AAIA,MAAM,4BAA4B,GAAG,IAAI,GAAG,EAAkB;AAWvD,MAAM,+BAA+B,GAAoC,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,KAAI;AACtG,IAAA,MAAM,iBAAiB,GAAG,WAAW,CAAC,IAAI,CAAC;AAC3C,IAAA,4BAA4B,CAAC,GAAG,CAAC,iBAAiB,EAAE,SAAS,CAAC;AAChE;AAUO,MAAM,+BAA+B,GAAoC,OAAO,EAAE,UAAU,EAAE,KAAI;AACvG,IAAA,MAAM,aAAa,GAAG,WAAW,CAAC,UAAU,CAAC;IAC7C,IAAI,CAAC,4BAA4B,CAAC,GAAG,CAAC,aAAa,CAAC,EAAE;QACpD,MAAM,SAAS,GAAG,MAAM,wBAAwB,CAAC,EAAE,UAAU,EAAE,aAAa,EAAE,CAAC;QAC/E,IAAI,SAAS,EAAE;YACb,+BAA+B,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,SAAS,EAAE,CAAC;QACrE;AACA,QAAA,OAAO,SAAS;IAClB;AACA,IAAA,OAAO,4BAA4B,CAAC,GAAG,CAAC,aAAa,CAAC;AACxD;;;;"}

package/dist/vite/index.js

@@ -0,0 +1,460 @@
+// Get the plugin file's URL to use as importer context for resolving SDK dependencies
+// @ts-expect-error - import.meta.url is valid in ESM but TypeScript config may not recognize it
+const PLUGIN_FILE_URL = import.meta.url;
+const DEFAULT_FS_MODULES = [
+    'fs',
+    'fs/promises',
+    'node:fs',
+    'node:fs/promises',
+];
+// Modules that other polyfill plugins commonly alias fs to
+const KNOWN_POLYFILL_TARGETS = [
+    'memfs',
+    'browserfs',
+    'rollup-plugin-node-polyfills/polyfills/fs',
+    'vite-plugin-node-polyfills/shims/fs',
+    'node-stdlib-browser/esm/mock/empty',
+    'node-stdlib-browser/esm/mock/empty.js',
+    '\0vite/node-polyfills/fs',
+    '\0node-polyfills:fs',
+    'empty',
+    '\0empty',
+    '__vite-browser-external',
+];
+// Common dependencies that are frequently used by the SDK and should be pre-optimized
+// to prevent incremental discovery and multiple reloads
+// Note: Only include these if autoIncludeDeps is enabled, as they might not be
+// installed in the consuming project (they're in the SDK's node_modules)
+const COMMON_DEPENDENCIES = [
+    '@zenfs/core',
+    '@zenfs/dom',
+    'path-browserify',
+    'graphql-request',
+    'tslib',
+    'reflect-metadata',
+    '@sinclair/typebox',
+    '@sinclair/typebox/value',
+    'immer',
+    'rxjs',
+    'xstate',
+    'lodash-es',
+    'use-immer',
+    '@xstate/react',
+    'ethers',
+    'eventemitter3',
+    '@statelyai/inspect',
+    'arweave',
+    // Note: node:crypto is a Node.js built-in and cannot be optimized
+];
+function seedVitePlugin(options = {}) {
+    const { fsModules = DEFAULT_FS_MODULES, autoInit = true, debug = false, entryPoints, autoIncludeDeps = false, } = options;
+    const log = (...args) => {
+        if (debug)
+            console.log('[seed-vite-plugin]', ...args);
+    };
+    // Track what other plugins have done to fs
+    const interceptedResolutions = new Map();
+    /**
+     * First plugin: runs early to observe what other plugins do and set up aliases
+     */
+    const observerPlugin = {
+        name: 'seed-protocol:observer',
+        enforce: 'pre',
+        config(userConfig) {
+            // Set up aliases early to override other plugins' fs polyfills
+            const aliases = [];
+            for (const fsModule of fsModules) {
+                const isPromiseVariant = fsModule.includes('promises');
+                const zenfsModule = isPromiseVariant ? '@zenfs/core/promises' : '@zenfs/core';
+                aliases.push({
+                    find: new RegExp(`^${fsModule.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}$`),
+                    replacement: zenfsModule,
+                });
+            }
+            // Also alias the node-stdlib-browser empty mock to @zenfs/core
+            // This ensures Vite can resolve it properly without needing manual resolution
+            aliases.push({
+                find: /^node-stdlib-browser\/esm\/mock\/empty(\.js)?$/,
+                replacement: '@zenfs/core',
+            }, {
+                find: /node-stdlib-browser\/esm\/mock\/empty(\.js)?$/,
+                replacement: '@zenfs/core',
+            });
+            return {
+                resolve: {
+                    alias: aliases,
+                },
+                optimizeDeps: {
+                    exclude: [
+                        'fs',
+                        'node:fs',
+                        'fs/promises',
+                        'node:fs/promises',
+                        // Also exclude the empty mock to prevent it from being cached
+                        'node-stdlib-browser/esm/mock/empty',
+                        'node-stdlib-browser/esm/mock/empty.js',
+                        // Exclude drizzle-kit and database drivers that it dynamically imports
+                        // These are dev tools and should not be bundled
+                        'drizzle-kit',
+                        '@electric-sql/pglite',
+                        'pg',
+                        'postgres',
+                        '@vercel/postgres',
+                        '@neondatabase/serverless',
+                        'mysql2',
+                        'mysql2/promise',
+                        '@planetscale/database',
+                    ],
+                },
+            };
+        },
+        async resolveId(source, importer, options) {
+            // Remove query parameters for matching
+            const sourceWithoutQuery = source.split('?')[0];
+            // Intercept fs imports early, before other plugins can create polyfills
+            if (fsModules.includes(source) || fsModules.includes(sourceWithoutQuery)) {
+                log(`[observer] Early interception of: "${source}" from ${importer}`);
+                const isPromiseVariant = source.includes('promises');
+                const zenfsModule = isPromiseVariant ? '@zenfs/core/promises' : '@zenfs/core';
+                // Resolve from plugin's context (SDK's node_modules)
+                const resolved = await this.resolve(zenfsModule, PLUGIN_FILE_URL, {
+                    ...options,
+                    skipSelf: true,
+                });
+                if (resolved) {
+                    log(`[observer] Resolved to: ${resolved.id}`);
+                    return resolved;
+                }
+            }
+            // Also intercept node-stdlib-browser empty mock if it's being used
+            // Match various formats: full path, relative path, with/without query params
+            if (source.includes('node-stdlib-browser') &&
+                (source.includes('mock/empty') || source.includes('empty.js'))) {
+                log(`[observer] Intercepting node-stdlib-browser empty mock: "${source}"`);
+                const isPromiseVariant = source.includes('promises');
+                const zenfsModule = isPromiseVariant ? '@zenfs/core/promises' : '@zenfs/core';
+                // Try resolving from plugin context first (SDK's node_modules)
+                let resolved = await this.resolve(zenfsModule, PLUGIN_FILE_URL, {
+                    ...options,
+                    skipSelf: true,
+                });
+                // If that fails and we have an importer, try resolving from the importer
+                if (!resolved && importer) {
+                    resolved = await this.resolve(zenfsModule, importer, {
+                        ...options,
+                        skipSelf: true,
+                    });
+                }
+                if (resolved) {
+                    log(`[observer] Resolved empty mock to: ${resolved.id}`);
+                    return resolved;
+                }
+                // If resolution fails, return null and let Vite handle it naturally
+                // Vite should be able to resolve @zenfs/core from node_modules
+                log(`[observer] Resolution failed, letting Vite handle: ${zenfsModule}`);
+                return null;
+            }
+            return null;
+        },
+        configResolved(resolvedConfig) {
+            // Log any fs-related aliases from other plugins
+            const aliases = resolvedConfig.resolve.alias;
+            if (debug && aliases) {
+                const aliasArray = Array.isArray(aliases) ? aliases : Object.entries(aliases);
+                for (const alias of aliasArray) {
+                    const [find, replacement] = Array.isArray(alias)
+                        ? [alias[0], alias[1]]
+                        : [alias.find, alias.replacement];
+                    if (typeof find === 'string' && fsModules.some(m => find.includes('fs'))) {
+                        log(`Detected existing alias: ${find} -> ${replacement}`);
+                    }
+                }
+            }
+        },
+    };
+    /**
+     * Main plugin: enforced to run last in the chain
+     */
+    const mainPlugin = {
+        name: 'seed-protocol:main',
+        enforce: 'post',
+        config(userConfig) {
+            // Pre-optimize common dependencies to prevent incremental discovery
+            // This reduces the number of reloads by ensuring dependencies are optimized upfront
+            // Note: Only include if autoIncludeDeps is true, as these dependencies might not
+            // be installed in the consuming project (they're in the SDK's node_modules)
+            const existingInclude = userConfig.optimizeDeps?.include || [];
+            // Normalize entries to always be an array (Vite allows string | string[])
+            const existingEntriesRaw = userConfig.optimizeDeps?.entries;
+            const existingEntries = Array.isArray(existingEntriesRaw)
+                ? existingEntriesRaw
+                : existingEntriesRaw
+                    ? [existingEntriesRaw]
+                    : [];
+            const optimizeDepsConfig = {
+                esbuildOptions: {
+                    define: {
+                        global: 'globalThis',
+                    },
+                },
+            };
+            // Only auto-include dependencies if explicitly enabled
+            // Vite will discover dependencies automatically if they're imported
+            if (autoIncludeDeps) {
+                const include = Array.isArray(existingInclude)
+                    ? [...new Set([...existingInclude, ...COMMON_DEPENDENCIES])]
+                    : [...COMMON_DEPENDENCIES];
+                optimizeDepsConfig.include = include;
+                if (debug) {
+                    log(`[main] Auto-including common dependencies: ${COMMON_DEPENDENCIES.join(', ')}`);
+                }
+            }
+            else if (Array.isArray(existingInclude) && existingInclude.length > 0) {
+                // Preserve existing includes if provided
+                optimizeDepsConfig.include = existingInclude;
+            }
+            // If entry points are provided, merge them with existing entries
+            // This helps Vite discover all dependencies during initial optimization
+            if (entryPoints && entryPoints.length > 0) {
+                const mergedEntries = Array.isArray(existingEntries)
+                    ? [...new Set([...existingEntries, ...entryPoints])]
+                    : entryPoints;
+                optimizeDepsConfig.entries = mergedEntries;
+                if (debug) {
+                    log(`[main] Using entry points for dependency scanning: ${mergedEntries.join(', ')}`);
+                }
+            }
+            else if (existingEntries.length > 0) {
+                // Preserve existing entries even if none provided
+                optimizeDepsConfig.entries = existingEntries;
+            }
+            return {
+                optimizeDeps: optimizeDepsConfig,
+            };
+        },
+        async resolveId(source, importer, options) {
+            // Check if this is an fs-related import we should intercept
+            const shouldIntercept = fsModules.includes(source) ||
+                KNOWN_POLYFILL_TARGETS.some(target => source.includes(target) || source === target);
+            // Also intercept node-stdlib-browser empty mock paths
+            if (source.includes('node-stdlib-browser') && source.includes('mock/empty')) {
+                log(`Intercepting node-stdlib-browser empty mock: "${source}"`);
+                const isPromiseVariant = source.includes('promises');
+                const zenfsModule = isPromiseVariant ? '@zenfs/core/promises' : '@zenfs/core';
+                // Try resolving from plugin context first (SDK's node_modules)
+                let resolved = await this.resolve(zenfsModule, PLUGIN_FILE_URL, {
+                    ...options,
+                    skipSelf: true,
+                });
+                // If that fails and we have an importer, try resolving from the importer
+                if (!resolved && importer) {
+                    resolved = await this.resolve(zenfsModule, importer, {
+                        ...options,
+                        skipSelf: true,
+                    });
+                }
+                if (resolved) {
+                    log(`Resolved empty mock to: ${resolved.id}`);
+                    interceptedResolutions.set(source, resolved.id);
+                    return resolved;
+                }
+                // If resolution fails, return null and let Vite handle it naturally
+                // The alias configuration should handle the resolution
+                log(`Resolution failed, letting Vite handle: ${zenfsModule}`);
+                return null;
+            }
+            if (!shouldIntercept) {
+                // Also intercept if source is a Vite pre-bundled fs polyfill path or node-stdlib-browser mock
+                source.split('?')[0];
+                if (source.includes('node_fs') ||
+                    (source.includes('.vite/deps') && source.includes('fs') && !source.includes('@zenfs')) ||
+                    (source.includes('node-stdlib-browser') && (source.includes('mock/empty') || source.includes('empty.js')))) {
+                    log(`Intercepting Vite pre-bundled fs polyfill/mock: "${source}"`);
+                    const isPromiseVariant = source.includes('promises');
+                    const zenfsModule = isPromiseVariant ? '@zenfs/core/promises' : '@zenfs/core';
+                    // For .vite/deps paths, let the load hook handle them to avoid chunk reference issues
+                    if (source.includes('.vite/deps')) {
+                        // Return null to let Vite continue, then the load hook will intercept
+                        return null;
+                    }
+                    // For other cases, resolve the module
+                    let resolved = await this.resolve(zenfsModule, importer || PLUGIN_FILE_URL, {
+                        ...options,
+                        skipSelf: true,
+                    });
+                    if (resolved) {
+                        log(`Resolved pre-bundled fs to: ${resolved.id}`);
+                        interceptedResolutions.set(source, resolved.id);
+                        return resolved;
+                    }
+                    // Fallback: return the module specifier
+                    log(`Fallback: returning module specifier: ${zenfsModule}`);
+                    interceptedResolutions.set(source, zenfsModule);
+                    return { id: zenfsModule, external: false };
+                }
+                return null;
+            }
+            log(`Intercepting resolution: "${source}" from ${importer}`);
+            // Determine the correct ZenFS module
+            const isPromiseVariant = source.includes('promises');
+            const zenfsModule = isPromiseVariant ? '@zenfs/core/promises' : '@zenfs/core';
+            // First, try resolving from the plugin's context (SDK's node_modules)
+            // This ensures we use the SDK's dependencies even if the consuming project doesn't have them
+            let resolved = await this.resolve(zenfsModule, PLUGIN_FILE_URL, {
+                ...options,
+                skipSelf: true,
+            });
+            // If that fails, try resolving from the original importer (project's node_modules)
+            if (!resolved && importer) {
+                resolved = await this.resolve(zenfsModule, importer, {
+                    ...options,
+                    skipSelf: true,
+                });
+            }
+            if (resolved) {
+                log(`Resolved to: ${resolved.id}`);
+                interceptedResolutions.set(source, resolved.id);
+                return resolved;
+            }
+            // Fallback: return the module specifier and let Vite handle it
+            // Vite should be able to resolve from parent node_modules automatically
+            log(`Fallback resolution for: ${zenfsModule}`);
+            return { id: zenfsModule, external: false };
+        },
+        shouldTransformCachedModule({ id, code }) {
+            // Force transformation of cached fs polyfill modules
+            const idWithoutQuery = id.split('?')[0];
+            const isFsPolyfill = idWithoutQuery.includes('node_fs') ||
+                (idWithoutQuery.includes('.vite/deps') && idWithoutQuery.includes('fs') && !idWithoutQuery.includes('@zenfs')) ||
+                (idWithoutQuery.includes('node-stdlib-browser') && (idWithoutQuery.includes('mock/empty') || idWithoutQuery.includes('empty.js')));
+            if (isFsPolyfill) {
+                log(`Forcing transformation of cached fs polyfill: ${id}`);
+                return true;
+            }
+            return false;
+        },
+        load(id) {
+            // Remove query parameters for matching (e.g., ?v=392cb483)
+            const idWithoutQuery = id.split('?')[0];
+            // Intercept Vite's pre-bundled fs polyfill and replace it with ZenFS
+            // Also intercept node-stdlib-browser's empty mock
+            // Handle both regular paths and /@fs/ prefixed paths
+            const isFsPolyfill = idWithoutQuery.includes('node_fs') ||
+                (idWithoutQuery.includes('.vite/deps') && idWithoutQuery.includes('fs') && !idWithoutQuery.includes('@zenfs')) ||
+                (idWithoutQuery.includes('node-stdlib-browser') && (idWithoutQuery.includes('mock/empty') || idWithoutQuery.includes('empty.js')));
+            if (isFsPolyfill) {
+                log(`Intercepting load of fs polyfill/mock file: ${id}`);
+                const isPromiseVariant = idWithoutQuery.includes('promises');
+                const zenfsModule = isPromiseVariant ? '@zenfs/core/promises' : '@zenfs/core';
+                // Return a re-export from ZenFS
+                return `export * from '${zenfsModule}'; export { default } from '${zenfsModule}';`;
+            }
+            return null;
+        },
+        handleHotUpdate({ file, server }) {
+            // Invalidate modules that import fs when the plugin file changes
+            // This helps with HMR scenarios where the cache might be stale
+            if (file.includes('node-stdlib-browser') && file.includes('empty')) {
+                log(`Invalidating modules due to fs polyfill change: ${file}`);
+                // Let Vite handle the invalidation naturally
+                return undefined;
+            }
+            return undefined;
+        },
+        transform(code, id) {
+            // Skip node_modules except for specific problematic packages
+            if (id.includes('node_modules') && !id.includes('@seedprotocol')) {
+                return null;
+            }
+            // Handle dynamic imports of fs
+            const dynamicFsImportPattern = /import\s*\(\s*['"`](fs|node:fs|fs\/promises|node:fs\/promises)['"`]\s*\)/g;
+            if (dynamicFsImportPattern.test(code)) {
+                log(`Transforming dynamic fs imports in: ${id}`);
+                const transformed = code.replace(dynamicFsImportPattern, (match, moduleName) => {
+                    const isPromise = moduleName.includes('promises');
+                    const replacement = isPromise ? '@zenfs/core/promises' : '@zenfs/core';
+                    return `import('${replacement}')`;
+                });
+                return {
+                    code: transformed,
+                    map: null,
+                };
+            }
+            return null;
+        },
+        transformIndexHtml(html) {
+            if (!autoInit)
+                return html;
+            // Inject ZenFS initialization script before other scripts
+            const initScript = `
+<script type="module">
+  import { configure } from '@zenfs/core';
+  import { IndexedDB } from '@zenfs/dom';
+  
+  window.__seedFsReady = configure({
+    mounts: {
+      '/': IndexedDB,
+    },
+  }).then(() => {
+    console.log('[seed-protocol] ZenFS initialized');
+  }).catch(err => {
+    console.error('[seed-protocol] ZenFS initialization failed:', err);
+  });
+</script>`;
+            // Insert before closing head tag or at the start of body
+            if (html.includes('</head>')) {
+                return html.replace('</head>', `${initScript}\n</head>`);
+            }
+            return html.replace('<body>', `<body>\n${initScript}`);
+        },
+        buildEnd() {
+            if (debug && interceptedResolutions.size > 0) {
+                log('Summary of intercepted resolutions:');
+                for (const [source, target] of interceptedResolutions) {
+                    log(`  ${source} -> ${target}`);
+                }
+            }
+        },
+    };
+    /**
+     * Cleanup plugin: catches any remaining fs references in the final bundle
+     */
+    const cleanupPlugin = {
+        name: 'seed-protocol:cleanup',
+        enforce: 'post',
+        apply: 'build',
+        generateBundle(options, bundle) {
+            for (const [fileName, chunk] of Object.entries(bundle)) {
+                if (chunk.type !== 'chunk')
+                    continue;
+                // Check for any remaining problematic fs references
+                const problematicPatterns = [
+                    /require\s*\(\s*['"`]fs['"`]\s*\)/g,
+                    /from\s*['"`]fs['"`]/g,
+                    /__vite-browser-external.*fs/g,
+                ];
+                let hasIssue = false;
+                for (const pattern of problematicPatterns) {
+                    if (pattern.test(chunk.code)) {
+                        hasIssue = true;
+                        log(`Warning: Potential unresolved fs reference in ${fileName}`);
+                        break;
+                    }
+                }
+                if (hasIssue && debug) {
+                    // Log the context around the problematic reference
+                    const lines = chunk.code.split('\n');
+                    lines.forEach((line, i) => {
+                        if (line.includes('fs') && (line.includes('require') || line.includes('from'))) {
+                            log(`  Line ${i + 1}: ${line.substring(0, 100)}...`);
+                        }
+                    });
+                }
+            }
+        },
+    };
+    return [observerPlugin, mainPlugin, cleanupPlugin];
+}
+
+export { seedVitePlugin as default, seedVitePlugin };
+//# sourceMappingURL=index.js.map