@feltdb/core 0.6.12 → 0.6.14

package/dist/agent-registry.js

@@ -8,9 +8,7 @@
  * Registry for agent definitions and discovery
  */
 export class AgentRegistry {
-    constructor() {
-        this.agents = new Map();
-    }
+    agents = new Map();
     /**
      * Register an agent definition
      */

package/dist/agent-runtime.js

@@ -9,10 +9,8 @@ import { AgentExecutionStatus, generateExecutionId } from './agent.js';
  * Agent ownership manager for distributed execution
  */
 export class AgentOwnershipManager {
-    constructor() {
-        this.ownership = new Map(); // executionId -> peerId
-        this.locks = new Map();
-    }
+    ownership = new Map(); // executionId -> peerId
+    locks = new Map();
     /**
      * Claim ownership of an execution
      */
@@ -86,10 +84,13 @@ export class AgentOwnershipManager {
  * Manages agent lifecycle and execution across the distributed fabric.
  */
 export class AgentRuntime {
+    config;
+    registry;
+    handlers = new Map();
+    executions = new Map();
+    ownership;
+    triggers = new Map();
     constructor(registry, config) {
-        this.handlers = new Map();
-        this.executions = new Map();
-        this.triggers = new Map();
         this.registry = registry;
         this.config = config;
         this.ownership = new AgentOwnershipManager();

package/dist/analytics-backend.js

@@ -10,8 +10,9 @@ import { IndexAnalytics as TypeScriptIndexAnalytics } from './index-analytics.js
  * Analytics backend selector with dynamic WASM loading
  */
 export class AnalyticsBackend {
+    backend;
+    wasmLoaded = false;
     constructor() {
-        this.wasmLoaded = false;
         // Start with TypeScript backend, attempt WASM load async
         // Create a wrapper that implements the interface
         const tsBackend = new TypeScriptIndexAnalytics();
@@ -76,6 +77,7 @@ export class AnalyticsBackend {
  * Adapter to bridge WASM analytics to TypeScript interface
  */
 class WasmAnalyticsAdapter {
+    wasm;
     constructor(wasm) {
         this.wasm = wasm;
     }

package/dist/application-contract.js

@@ -1,4 +1,5 @@
 export class ApplicationContractClient {
+    request;
     constructor(request) {
         this.request = request;
     }

package/dist/application-manifest.js

@@ -1,4 +1,5 @@
 export class ApplicationManifestClient {
+    baseUrl;
     constructor(baseUrl = '') {
         this.baseUrl = baseUrl;
     }

package/dist/artifact.js

@@ -1,4 +1,6 @@
 export class ArtifactClient {
+    baseUrl;
+    fetcher;
     constructor(baseUrl = '', fetcher = fetch) {
         this.baseUrl = baseUrl;
         this.fetcher = fetcher;

package/dist/authorization.js

@@ -1,4 +1,6 @@
 export class AuthorizationClient {
+    baseUrl;
+    fetcher;
     constructor(baseUrl = '', fetcher = fetch) {
         this.baseUrl = baseUrl;
         this.fetcher = fetcher;

package/dist/bundle.js

@@ -1,4 +1,6 @@
 export class BundleClient {
+    baseUrl;
+    fetcher;
     constructor(baseUrl = '', fetcher = fetch) {
         this.baseUrl = baseUrl;
         this.fetcher = fetcher;

package/dist/capability.js

@@ -4,9 +4,7 @@
  * Capabilities are distributed, pluggable features like search, vector embeddings, etc.
  */
 export class CapabilityRegistry {
-    constructor() {
-        this.capabilities = new Map();
-    }
+    capabilities = new Map();
     register(capability) {
         this.capabilities.set(capability.id, capability);
     }

package/dist/cell.js

@@ -16,11 +16,16 @@ export const AUTHORITY_CONFLICT = Symbol('FELTDB_AUTHORITY_CONFLICT');
  * A replica is read-only: replication transfers knowledge, not authority.
  */
 export class CellImpl {
+    id;
+    jsDb;
+    cellCollection;
+    replicaCollection;
+    failureObservationCollection;
+    mutationQueue = [];
+    isLocked = false;
+    changeHandlers = [];
+    isReplica = false;
     constructor(jsDb, cellId) {
-        this.mutationQueue = [];
-        this.isLocked = false;
-        this.changeHandlers = [];
-        this.isReplica = false;
         this.id = cellId;
         this.jsDb = jsDb;
         this.cellCollection = new Collection(jsDb, '_cells', undefined, undefined, false);

package/dist/cli/application.js

@@ -71,7 +71,7 @@ export function applicationUrlCandidate(project, environment = process.env) {
     if (project.configuredUrl)
         return project.configuredUrl;
     if (project.configuredPort)
-        return `http://127.0.0.1:${project.configuredPort}`;
+        return `http://localhost:${project.configuredPort}/`;
     return undefined;
 }
 export function applicationIsRunning(url, timeoutMs = 750) {

package/dist/cli/browser-opening.js

@@ -0,0 +1,35 @@
+import { spawn } from 'child_process';
+function defaultSpawn(command, args) {
+    return spawn(command, [...args], { detached: true, stdio: 'ignore' });
+}
+export function browserCommand(url, platform = process.platform) {
+    if (platform === 'darwin')
+        return ['open', [url]];
+    if (platform === 'win32')
+        return ['cmd', ['/c', 'start', '', url]];
+    if (platform === 'linux')
+        return ['xdg-open', [url]];
+    return null;
+}
+export function openBrowser(url, spawnBrowser = defaultSpawn) {
+    const command = browserCommand(url);
+    if (!command || !process.stdout.isTTY || process.env.CI)
+        return false;
+    try {
+        const child = spawnBrowser(command[0], command[1]);
+        child.once('error', () => undefined);
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function openApplication(url) {
+    console.log(`🌐 Application: ${url}`);
+    return openBrowser(url);
+}
+export function openStudio(url) {
+    console.log(`🛠️  Studio:     ${url}`);
+    return openBrowser(url);
+}

package/dist/cli/commands.js

@@ -13,6 +13,7 @@ import { discoverWorkspace, ensureWorkspaceGitIgnored, generatePairingToken, per
 import { applicationUrlCandidate, detectApplication, discoverApplicationUrl } from './application.js';
 import { resolveApplicationLifecycle, startManagedApplication, waitForManagedApplication } from './application-lifecycle.js';
 import { createDevelopmentSession, developmentSessionEnvironment, developmentSessionSummary, transitionDevelopmentSession } from './development-session.js';
+import { openApplication, openStudio } from './browser-opening.js';
 function loadProjectEnvironment(file = path.resolve('.env.local')) {
     if (!fs.existsSync(file))
         return;
@@ -511,7 +512,7 @@ async function handleDev(args) {
     if (args.includes('--help')) {
         console.log('Usage: feltdb dev [--app-url URL] [--studio-port 7701] [--authority-port 7700] [--discovery-port 7799] [--no-open]');
         console.log('\nOptions:');
-        console.log('  --app-url <url>           Application URL (e.g., http://127.0.0.1:3000)');
+        console.log('  --app-url <url>           Application URL (e.g., http://localhost:3000/)');
         console.log('  --studio-port <port>      FeltDB Studio port (default: 7701)');
         console.log('  --authority-port <port>   Authority port (default: 7700)');
         console.log('  --discovery-port <port>   Pairing discovery port (default: 7799)');
@@ -628,7 +629,7 @@ async function handleDev(args) {
         console.log(`Attaching existing FeltDB application (${detectedApplication.feltDBSignals.join(', ')})\n`);
     }
     const requestedStudioPort = Number(args.includes('--studio-port') ? args[args.indexOf('--studio-port') + 1] || '7701' : '7701');
-    const studioPort = String(await availablePort(requestedStudioPort));
+    const studioPort = String(await availablePort(requestedStudioPort, 'localhost'));
     if (studioPort !== String(requestedStudioPort))
         console.log(`⚠ Port ${requestedStudioPort} is busy; using ${studioPort} for Studio.\n`);
     process.env.STUDIO_PORT = studioPort;
@@ -678,7 +679,7 @@ async function handleDev(args) {
         storage: config.storage,
         lifecycle: applicationLifecycle,
         authorityUrl,
-        studioUrl: `http://127.0.0.1:${studioPort}`,
+        studioUrl: `http://localhost:${studioPort}/`,
         pairingUrl: `http://127.0.0.1:${discoveryPort}`,
         applicationUrl: appUrl,
     });
@@ -718,7 +719,14 @@ async function handleDev(args) {
         throw error;
     }
     let stopping = null;
+    // The development session runs until something stops it — a signal, a managed
+    // application exiting, or a failure. Its lifetime belongs to this command, so
+    // it is represented explicitly rather than borrowed from whichever service
+    // happens to be long-running.
+    let releaseSession = () => { };
+    const sessionStopped = new Promise(resolve => { releaseSession = resolve; });
     const stopAll = () => stopping ?? (stopping = (async () => {
+        releaseSession();
         if (developmentSession && developmentSession.state !== 'STOPPING' && developmentSession.state !== 'STOPPED') {
             transitionDevelopmentSession(developmentSession, 'STOPPING');
         }
@@ -791,7 +799,7 @@ async function handleDev(args) {
     else {
         console.log('❌ No application URL is configured.\n');
         console.log('Start your application, then run:\n');
-        console.log('  feltdb dev --app-url http://127.0.0.1:<port>\n');
+        console.log('  feltdb dev --app-url http://localhost:<port>/\n');
         console.log('Or set applicationUrl in feltdb.config.json\n');
         console.log('FeltDB workspace is ready at:');
         console.log('Authority: ' + developmentSession.authorityUrl);
@@ -812,19 +820,47 @@ async function handleDev(args) {
             '--lifecycle', developmentSession.lifecycle,
             ...(developmentSession.applicationUrl ? ['--app-url', developmentSession.applicationUrl] : []),
             ...((developmentSession.runtime === 'self-hosted' || developmentSession.runtime === 'managed') ? ['--connect', developmentSession.authorityUrl] : []),
-            ...(open ? [] : ['--no-open']),
-        ], () => {
+            '--no-open',
+        ], studioUrl => {
+            developmentSession.studioUrl = studioUrl;
             transitionDevelopmentSession(developmentSession, 'READY');
             console.log(`\n${developmentSessionSummary(developmentSession)}\n`);
+            if (open) {
+                if (developmentSession.applicationUrl)
+                    openApplication(developmentSession.applicationUrl);
+                openStudio(developmentSession.studioUrl);
+            }
+            else {
+                if (developmentSession.applicationUrl)
+                    console.log(`🌐 Application: ${developmentSession.applicationUrl}`);
+                console.log(`🛠️  Studio:     ${developmentSession.studioUrl}`);
+            }
             transitionDevelopmentSession(developmentSession, 'RUNNING');
         });
+        // Studio is one service in the session, not the session itself.
+        // `handleStudio` returns immediately when Studio's static assets are absent,
+        // and awaiting it as the session's lifetime meant a missing optional
+        // artifact tore down the authority, the pairing discovery server, and the
+        // workspace transport: the process printed "workspace is ready" and then
+        // exited, so anything reaching for the discovery endpoint afterwards got a
+        // connection failure. The session now outlives Studio either way.
+        void studio.then(() => {
+            if (!developmentSession || developmentSession.state === 'RUNNING')
+                return;
+            console.log('\u26a0\ufe0f  Studio is unavailable for this session. The authority, pairing discovery, and workspace transport are unaffected.');
+            transitionDevelopmentSession(developmentSession, 'READY');
+            console.log(`\n${developmentSessionSummary(developmentSession)}\n`);
+            transitionDevelopmentSession(developmentSession, 'RUNNING');
+        }).catch(error => {
+            console.error(`Studio failed: ${error instanceof Error ? error.message : String(error)}`);
+        });
         if (managedApplication) {
-            await Promise.race([studio, managedApplication.exited.then(exit => {
+            await Promise.race([sessionStopped, managedApplication.exited.then(exit => {
                     throw new Error(`Managed application stopped during the development session (command: ${managedApplication.command}; exit: ${exit.code ?? exit.signal})`);
                 })]);
         }
         else
-            await studio;
+            await sessionStopped;
     }
     finally {
         await stopAll();
@@ -1092,8 +1128,8 @@ async function handleStudio(args, onReady) {
         ? args[args.indexOf('--port') + 1] || '7701'
         : '7701';
     const host = args.includes('--host')
-        ? args[args.indexOf('--host') + 1] || '127.0.0.1'
-        : '127.0.0.1';
+        ? args[args.indexOf('--host') + 1] || 'localhost'
+        : 'localhost';
     const open = !args.includes('--no-open');
     const namespace = args.includes('--namespace')
         ? args[args.indexOf('--namespace') + 1] || 'default'
@@ -1223,15 +1259,12 @@ async function handleStudio(args, onReady) {
     if (session.pairingUrl)
         parameters.set('pairing', session.pairingUrl);
     const query = `?${parameters.toString()}`;
-    const studioUrl = `http://127.0.0.1:${port}/${query}`;
+    const studioUrl = `http://localhost:${port}/${query}`;
     console.log(`FeltDB Studio ready at ${studioUrl}`);
-    onReady?.();
+    onReady?.(studioUrl);
     console.log('Use Ctrl+C to stop the server.');
-    if (open) {
-        const command = process.platform === 'darwin' ? ['open', studioUrl] : process.platform === 'win32' ? ['cmd', '/c', 'start', '', studioUrl] : ['xdg-open', studioUrl];
-        const child = spawn(command[0], command.slice(1), { detached: true, stdio: 'ignore' });
-        child.unref();
-    }
+    if (open)
+        openStudio(studioUrl);
     await new Promise(() => { });
 }
 function handleHelp() {

package/dist/cli/index.js

@@ -23,7 +23,7 @@ import * as path from 'path';
 import * as readline from 'readline';
 import { getClient } from './api-client.js';
 import { loadFeltDBConfig, createDefaultConfig, validateModel, } from './config.js';
-const VERSION = '0.6.12';
+const VERSION = '0.6.14';
 function prompt(question) {
     const rl = readline.createInterface({
         input: process.stdin,

package/dist/collection.js

@@ -18,38 +18,42 @@ import { IndexStore } from './index-store.js';
  * Uses reactive dependency graph instead of polling for efficient updates.
  */
 export class Collection {
+    db;
+    name;
+    collectionId; // Unique ID for this collection instance
+    predicate = null;
+    cache = [];
+    subscribers = new Set();
+    parent = null;
+    parentId = null;
+    isInitialized = false;
+    unsubscribeFunctions = new Set();
+    graphUnsubscribe = null;
+    runtimeUnsubscribe = null;
+    indexBackend = new IndexBackend();
+    indexStore;
+    indexesLoaded = false;
+    /** Incremented whenever `cache` is replaced, so the index can tell it is stale. */
+    cacheGeneration = 0;
+    /** The cache generation the index entries currently reflect, or -1 for none. */
+    indexedGeneration = -1;
+    lastPlan = null;
+    /** Cache records addressed by id, valid for `indexedGeneration`. */
+    recordsById = null;
+    /** Raw payload the cache was parsed from, used to detect that nothing changed. */
+    lastRawSnapshot = null;
+    /**
+     * The runtime revision the cache was built from, when the runtime offers one.
+     *
+     * Captured *before* the query that produced the cache, never after. A write
+     * landing between the two then makes this older than the data it labels,
+     * which costs one unnecessary refresh. Capturing it after would make it
+     * newer than the data, and the cache would look current forever.
+     */
+    cachedRevision = null;
+    /** How the last refresh decided the cache was usable. Reporting only. */
+    lastFreshness = null;
     constructor(db, name, predicate, parent, loadIndexes = true) {
-        this.predicate = null;
-        this.cache = [];
-        this.subscribers = new Set();
-        this.parent = null;
-        this.parentId = null;
-        this.isInitialized = false;
-        this.unsubscribeFunctions = new Set();
-        this.graphUnsubscribe = null;
-        this.runtimeUnsubscribe = null;
-        this.indexBackend = new IndexBackend();
-        this.indexesLoaded = false;
-        /** Incremented whenever `cache` is replaced, so the index can tell it is stale. */
-        this.cacheGeneration = 0;
-        /** The cache generation the index entries currently reflect, or -1 for none. */
-        this.indexedGeneration = -1;
-        this.lastPlan = null;
-        /** Cache records addressed by id, valid for `indexedGeneration`. */
-        this.recordsById = null;
-        /** Raw payload the cache was parsed from, used to detect that nothing changed. */
-        this.lastRawSnapshot = null;
-        /**
-         * The runtime revision the cache was built from, when the runtime offers one.
-         *
-         * Captured *before* the query that produced the cache, never after. A write
-         * landing between the two then makes this older than the data it labels,
-         * which costs one unnecessary refresh. Capturing it after would make it
-         * newer than the data, and the cache would look current forever.
-         */
-        this.cachedRevision = null;
-        /** How the last refresh decided the cache was usable. Reporting only. */
-        this.lastFreshness = null;
         this.db = db;
         this.name = name;
         this.collectionId = `${name}-${Math.random().toString(36).substr(2, 9)}`;
@@ -690,6 +694,10 @@ export class Collection {
  * Relationship helper for loading related data.
  */
 export class Relationship {
+    parentDb;
+    childDb;
+    childCollection;
+    foreignKey;
     constructor(parentDb, childDb, childCollection, foreignKey) {
         this.parentDb = parentDb;
         this.childDb = childDb;

package/dist/create/cli.js

@@ -11,6 +11,7 @@ import { spawn, spawnSync } from 'child_process';
 import { createProject } from './create.js';
 import { FELTDB_PACKAGE_VERSION } from './package-versions.js';
 import { configureManagedAccount } from './managed-account.js';
+import { localFeltdbExecutable } from './development-handoff.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 function parseArgs(args) {
     const options = {
@@ -235,7 +236,7 @@ Options:
   --no-webllm              Do not install WebLLM or generate the AI builder
   --capabilities <list>    Choose capabilities: search, vector, or search,vector
   --no-install             Skip npm install
-  --no-start               Skip npm run dev
+  --no-start               Skip automatic feltdb dev startup
   -y, --yes                Use all defaults (non-interactive mode)
   -h, --help               Show this help message
   --version                Show version number
@@ -314,6 +315,7 @@ Learn more: https://github.com/rkendel1/feltdb`);
             agents: options.agents,
             webllm: options.webllm,
             capabilities: options.capabilities,
+            showNextSteps: false,
         });
         projectCreated = true;
         if (options.runtime === 'managed') {
@@ -335,18 +337,18 @@ Learn more: https://github.com/rkendel1/feltdb`);
         }
         if (shouldStart) {
             if (!shouldInstall) {
-                console.log(`Start after installing dependencies:\n  cd ${projectName}\n  npm install\n  npm run dev\n`);
+                console.log(`Start after installing dependencies:\n  cd ${projectName}\n  npm install\n  npm run feltdb:dev\n`);
             }
             else {
                 if (options.runtime === 'self-hosted' && spawnSync('docker', ['version'], { stdio: 'ignore' }).status !== 0) {
                     console.log('\n✅ Project and Docker image definition are ready.');
                     console.log('Docker is not currently running, so startup was skipped.');
-                    console.log(`Start Docker Desktop, then run:\n  cd ${projectName}\n  npm run dev`);
+                    console.log(`Start Docker Desktop, then run:\n  cd ${projectName}\n  npm run feltdb:dev`);
                     console.log('Build the production application image with: docker compose build app');
                 }
                 else {
-                    console.log('\n🚀 Starting the application...\n');
-                    await run(npm, ['run', 'dev'], projectDir);
+                    console.log('\n🚀 Starting your FeltDB development session...\n');
+                    await run(localFeltdbExecutable(projectDir), ['dev'], projectDir);
                 }
             }
         }

package/dist/create/create.js

@@ -87,7 +87,7 @@ export async function createProject(options) {
         application: {
             lifecycle: 'managed',
         },
-        applicationUrl: 'http://127.0.0.1:5173',
+        applicationUrl: 'http://localhost:5173/',
         capabilities: {},
     };
     if (capabilities.includes('search')) {
@@ -1657,7 +1657,7 @@ Configuration is in \`feltdb.config.json\`:
   "application": {
     "lifecycle": "managed"
   },
-  "applicationUrl": "http://127.0.0.1:5173",
+  "applicationUrl": "http://localhost:5173/",
   "capabilities": ["${capabilities}"]
 }
 \`\`\`
@@ -1810,9 +1810,11 @@ MIT
     console.log(`\n✓ Development Workspace initialized`);
     console.log(`  Workspace ID: ${workspaceDiscovery.workspaceId}`);
     console.log(`  Location: ${path.join(projectName, '.feltdb/workspace.json')}`);
-    console.log(`\nNext steps:`);
-    console.log(`  cd ${projectName}`);
-    console.log(`  npm install`);
-    console.log(`  npm run dev`);
-    console.log(`\nYour Development Workspace is ready for use!`);
+    if (options.showNextSteps !== false) {
+        console.log(`\nNext steps:`);
+        console.log(`  cd ${projectName}`);
+        console.log(`  npm install`);
+        console.log(`  npm run feltdb:dev`);
+        console.log(`\nYour Development Workspace is ready for use!`);
+    }
 }

package/dist/create/development-handoff.js

@@ -0,0 +1,4 @@
+import path from 'path';
+export function localFeltdbExecutable(projectDir, platform = process.platform) {
+    return path.join(projectDir, 'node_modules', '.bin', platform === 'win32' ? 'feltdb.cmd' : 'feltdb');
+}

package/dist/create/docker-compose-generator.js

@@ -38,9 +38,9 @@ export function generateDockerCompose(config) {
       - --data
       - /data/feltdb.log
       - --allow-origin
-      - http://127.0.0.1:\${APP_PORT:-5173}
+      - http://localhost:\${APP_PORT:-5173}
       - --allow-origin
-      - http://127.0.0.1:\${STUDIO_PORT:-${config.studioPort}}
+      - http://localhost:\${STUDIO_PORT:-${config.studioPort}}
     volumes:
       - feltdb_data:/data
       - ./feltdb.flow:/app/feltdb.flow:ro
@@ -97,7 +97,7 @@ export function generateDockerCompose(config) {
     container_name: \${COMPOSE_PROJECT_NAME}-studio
     environment:
       FELTDB_API_URL: \${FELTDB_PUBLIC_URL:-http://127.0.0.1:${config.port}}
-      APP_URL: \${APP_PUBLIC_URL:-http://127.0.0.1:5173}
+      APP_URL: \${APP_PUBLIC_URL:-http://localhost:5173/}
       FELTDB_NAMESPACE: \${FELTDB_APP_ID:-${config.appId}}
     ports:
       - "\${STUDIO_PORT:-${config.studioPort}}:8000"
@@ -140,7 +140,7 @@ USER feltdb
 EXPOSE 7700
 HEALTHCHECK --interval=10s --timeout=5s --start-period=30s --retries=3 CMD curl -fsS http://127.0.0.1:7700/health || exit 1
 ENTRYPOINT ["/sbin/tini", "--"]
-CMD ["feltdb-server", "--host", "0.0.0.0", "--port", "7700", "--namespace", "${config.appId}", "--data", "/data/feltdb.log", "--allow-origin", "http://127.0.0.1:5173", "--allow-origin", "http://127.0.0.1:${config.studioPort}"]
+CMD ["feltdb-server", "--host", "0.0.0.0", "--port", "7700", "--namespace", "${config.appId}", "--data", "/data/feltdb.log", "--allow-origin", "http://localhost:5173", "--allow-origin", "http://localhost:${config.studioPort}"]
 `;
 }
 export function generateStudioDockerfile(config) {

package/dist/create/package-versions.js

@@ -1,4 +1,4 @@
 // One release train keeps generated applications installable. The repository
 // validation script checks these values against every workspace manifest.
-export const FELTDB_PACKAGE_VERSION = '0.6.12';
+export const FELTDB_PACKAGE_VERSION = '0.6.14';
 export const feltdbPackageRange = `^${FELTDB_PACKAGE_VERSION}`;