@feltdb/core 0.7.2 → 0.7.4

package/dist/create/template/default-project/capabilities/project-search.ts

@@ -0,0 +1,16 @@
+import type { Capability } from '@feltdb/core';
+import { projects, type Project } from '../src/feltdb';
+
+export interface ProjectSearchResult { id: string; name: string; description: string }
+
+export const projectSearch: Capability = {
+  id: 'project-search',
+  name: 'Project search',
+  async execute(query: string): Promise<ProjectSearchResult[]> {
+    // The collection read crosses FeltDB's normal authorization boundary. The
+    // capability narrows results; it never grants access to additional rows.
+    const words = query.trim().toLowerCase();
+    const authorized = await projects.all() as Project[];
+    return authorized.filter(project => `${project.name} ${project.description}`.toLowerCase().includes(words)).map(({ id, name, description }) => ({ id, name, description }));
+  },
+};

package/dist/create/template/default-project/capabilities/project-summary.ts

@@ -0,0 +1,15 @@
+import type { Capability } from '@feltdb/core';
+import { auditEvents, projects, type AuditEvent, type Project } from '../src/feltdb';
+
+export interface ProjectSummary { title: string; summary: string; activityCount: number }
+
+export const projectSummary: Capability = {
+  id: 'project-summary',
+  name: 'Project summary',
+  async execute(projectId: string): Promise<ProjectSummary> {
+    const project = await projects.get(projectId) as Project | null;
+    if (!project) throw new Error('Project is unavailable in the current authorization context.');
+    const activity = (await auditEvents.all() as AuditEvent[]).filter(event => event.resource_id === project.id);
+    return { title: project.name, summary: project.description || `${project.name} is active and ready for its next state transition.`, activityCount: activity.length };
+  },
+};

package/dist/create/template/default-project/feltdb.flow

@@ -0,0 +1,169 @@
+flow_version 1
+
+app FeltDBStarter {
+  collection User {
+    email: text
+    name: text
+    created_at: datetime
+    index email using hash(email)
+  }
+  collection Organization {
+    name: text
+    created_at: datetime
+  }
+  collection Membership {
+    user: ref User
+    organization: ref Organization
+    role: text
+    created_at: datetime
+    index user using hash(user)
+    index organization using hash(organization)
+  }
+  collection Session {
+    user: ref User
+    expires_at: datetime
+    created_at: datetime
+    index user using hash(user)
+  }
+  collection Project {
+    organization: ref Organization
+    name: text
+    description: text
+    owner_id: text
+    created_at: datetime
+    updated_at: datetime
+    index organization using hash(organization)
+  }
+  collection Invitation {
+    organization: ref Organization
+    user: ref User
+    email: text
+    role: text
+    status: text
+    created_at: datetime
+    updated_at: datetime
+    index organization using hash(organization)
+  }
+  collection AuditEvent {
+    organization: ref Organization
+    user: ref User
+    action: text
+    resource_type: text
+    resource_id: text
+    details: text
+    created_at: datetime
+    index organization using hash(organization)
+  }
+  collection Team {
+    organization: ref Organization
+    name: text
+    description: text
+    owner: ref User
+    created_at: datetime
+    updated_at: datetime
+    index organization using hash(organization)
+  }
+  collection TeamMembership {
+    organization: ref Organization
+    team: ref Team
+    user: ref User
+    role: text
+    created_at: datetime
+    updated_at: datetime
+    index organization using hash(organization)
+  }
+
+  capability ProjectSearch {
+    visibility public
+    read Project
+  }
+  capability ProjectSummary {
+    visibility agent
+    read Project
+    read AuditEvent
+  }
+  capability ActivitySummary {
+    visibility agent
+    read AuditEvent
+  }
+  capability RecordAgentActivity {
+    visibility internal
+    write AuditEvent
+  }
+
+  workflow ProjectCreated {
+    step persist_project {
+      write Project
+    }
+    step record_activity {
+      write AuditEvent
+    }
+  }
+  workflow InvitationLifecycle {
+    step create_invitation {
+      write Invitation
+    }
+    step accept_invitation {
+      write Membership
+    }
+    step record_activity {
+      write AuditEvent
+    }
+  }
+  workflow AgentAssistedSummary {
+    step read_authorized_state {
+      capability ProjectSummary
+    }
+    step record_activity {
+      capability RecordAgentActivity
+    }
+  }
+
+  agent ProjectAssistant {
+    capability ProjectSearch
+    capability ProjectSummary
+    capability RecordAgentActivity
+    workflow AgentAssistedSummary
+  }
+  agent ActivityAssistant {
+    capability ActivitySummary
+    capability RecordAgentActivity
+    workflow AgentAssistedSummary
+  }
+  policy User {
+    read: authenticated
+    write: owner
+  }
+  policy Organization {
+    read: member
+    write: owner
+  }
+  policy Membership {
+    read: member
+    write: member
+  }
+  policy Session {
+    read: self(user)
+    write: self(user)
+  }
+  policy Project {
+    read: member
+    write: member
+  }
+  policy Invitation {
+    read: self(user) | member
+    write: member
+  }
+  policy AuditEvent {
+    read: member
+    write: authenticated
+  }
+  policy Team {
+    read: member
+    write: member
+  }
+  policy TeamMembership {
+    read: member
+    write: member
+  }
+}

package/dist/create/template/default-project/src/App.tsx

@@ -0,0 +1,20 @@
+import { AuthProvider, useAuth } from './context/AuthContext';
+import { Dashboard } from './pages/Dashboard';
+import { SignIn } from './pages/SignIn';
+import { SignUp } from './pages/SignUp';
+import './styles.css';
+import './styles-application.css';
+
+function Application() {
+  const { authenticated, loading } = useAuth();
+  if (loading) return <main className="center"><div className="loader" /><p>Resolving your FeltDB session…</p></main>;
+  if (!authenticated) return <AuthScreen />;
+  return <Dashboard />;
+}
+
+function AuthScreen() {
+  const signIn = new URLSearchParams(window.location.search).get('view') === 'signin';
+  return <main className="auth-layout"><section className="intro"><a className="brand" href="https://feltdb.com">FeltDB</a><div><span className="eyebrow">State first</span><h1>A real application, from the first command.</h1><p>Sign up to create a durable user, organization, membership, and session—then inspect all of it in Studio.</p></div><div className="flow"><span>Identity</span><i>→</i><span>Tenant</span><i>→</i><span>State</span></div></section><section className="auth-card">{signIn ? <SignIn /> : <SignUp />}</section></main>;
+}
+
+export function App() { return <AuthProvider><Application /></AuthProvider>; }

package/dist/create/template/default-project/src/context/AuthContext.tsx

@@ -0,0 +1,27 @@
+import { createContext, useContext, useEffect, useMemo, useState, type ReactNode } from 'react';
+import { useCollection } from '@feltdb/core/react';
+import { createAccount, createSession, db, memberships, organizations, sessions, users, type Membership, type Organization, type Session, type User } from '../feltdb';
+
+const SESSION_KEY = 'feltdb.example.session';
+interface AuthValue { loading: boolean; authenticated: boolean; user?: User; session?: Session; organization?: Organization; membership?: Membership; signUp(input: { name: string; email: string; password: string; organization: string }): Promise<void>; signIn(email: string, password: string): Promise<void>; signOut(): Promise<void> }
+const AuthContext = createContext<AuthValue | undefined>(undefined);
+
+export function AuthProvider({ children }: { children: ReactNode }) {
+  const sessionRecords = useCollection<Session>(sessions); const userRecords = useCollection<User>(users); const membershipRecords = useCollection<Membership>(memberships); const organizationRecords = useCollection<Organization>(organizations);
+  const [sessionId, setSessionId] = useState<string | null>(null);
+  useEffect(() => setSessionId(sessionStorage.getItem(SESSION_KEY)), []);
+  const session = sessionRecords.data.find(item => item.id === sessionId && Date.parse(item.expires_at) > Date.now());
+  const user = userRecords.data.find(item => item.id === session?.user);
+  const membership = membershipRecords.data.find(item => item.user === user?.id);
+  const organization = organizationRecords.data.find(item => item.id === membership?.organization);
+  const loading = sessionRecords.loading || userRecords.loading || membershipRecords.loading || organizationRecords.loading;
+  const establish = (next: Session) => { sessionStorage.setItem(SESSION_KEY, next.id); setSessionId(next.id); };
+  const value = useMemo<AuthValue>(() => ({ loading, authenticated: Boolean(session && user && membership && organization), session, user, membership, organization,
+    signUp: async input => { await db.auth.signUp({ email: input.email, password: input.password, display_name: input.name }); establish(await createAccount(input)); },
+    signIn: async (email, password) => { await db.auth.signIn({ email, password }); establish(await createSession(email)); },
+    signOut: async () => { if (session) await sessions.delete(session.id); await db.auth.signOut(); sessionStorage.removeItem(SESSION_KEY); setSessionId(null); },
+  }), [loading, session, user, membership, organization]);
+  return <AuthContext.Provider value={value}>{children}</AuthContext.Provider>;
+}
+
+export function useAuth() { const value = useContext(AuthContext); if (!value) throw new Error('useAuth must be used inside AuthProvider'); return value; }

package/dist/create/template/default-project/src/feltdb.ts

@@ -0,0 +1,87 @@
+import { configureDevelopmentRuntimeBridge, createFeltDB } from '@feltdb/core';
+
+configureDevelopmentRuntimeBridge({
+  sessionId: import.meta.env.VITE_FELTDB_DEV_SESSION_ID,
+  workspaceId: import.meta.env.VITE_FELTDB_WORKSPACE_ID,
+  namespace: import.meta.env.VITE_FELTDB_NAMESPACE,
+  runtime: import.meta.env.VITE_FELTDB_RUNTIME,
+  authorityUrl: import.meta.env.VITE_FELTDB_AUTHORITY_URL,
+  bridgeUrl: import.meta.env.VITE_FELTDB_DEV_BRIDGE_URL,
+  applicationUrl: import.meta.env.VITE_FELTDB_APPLICATION_URL,
+});
+
+export const managedRuntime = Boolean(import.meta.env.VITE_FELTDB_MANAGED_URL);
+export const db = createFeltDB(managedRuntime ? {
+  namespace: import.meta.env.VITE_FELTDB_MANAGED_NAMESPACE || 'feltdb-starter',
+  server: {
+    url: import.meta.env.VITE_FELTDB_MANAGED_URL,
+    applicationId: import.meta.env.VITE_FELTDB_MANAGED_APPLICATION_ID,
+    environment: import.meta.env.VITE_FELTDB_MANAGED_ENVIRONMENT || 'production',
+  },
+} : { namespace: import.meta.env.VITE_FELTDB_NAMESPACE || 'feltdb-starter', browser: true });
+
+export interface User { id: string; email: string; name: string; created_at: string }
+export interface Organization { id: string; name: string; created_at: string }
+export interface Membership { id: string; user: string; organization: string; role: 'owner' | 'member' | 'viewer'; created_at: string }
+export interface Session { id: string; user: string; expires_at: string; created_at: string }
+export interface Project { id: string; organization: string; name: string; description: string; owner_id: string; created_at: string; updated_at: string }
+export interface Invitation { id: string; organization: string; user: string; email: string; role: string; status: string; created_at: string; updated_at: string }
+export interface AuditEvent { id: string; organization: string; user: string; action: string; resource_type: string; resource_id: string; details: string; created_at: string }
+export interface Team { id: string; organization: string; name: string; description: string; owner: string; created_at: string; updated_at: string }
+export interface TeamMembership { id: string; organization: string; team: string; user: string; role: string; created_at: string; updated_at: string }
+
+export const users = db.collection<User>('User');
+export const organizations = db.collection<Organization>('Organization');
+export const memberships = db.collection<Membership>('Membership');
+export const sessions = db.collection<Session>('Session');
+export const projects = db.collection<Project>('Project');
+export const invitations = db.collection<Invitation>('Invitation');
+export const auditEvents = db.collection<AuditEvent>('AuditEvent');
+export const teams = db.collection<Team>('Team');
+export const teamMemberships = db.collection<TeamMembership>('TeamMembership');
+
+const makeId = (prefix: string) => `${prefix}_${crypto.randomUUID()}`;
+
+export async function createAccount(input: { name: string; email: string; organization: string }) {
+  const email = input.email.trim().toLowerCase();
+  if ((await users.find({ email })).length) throw new Error('An account already exists for that email.');
+  const now = new Date().toISOString();
+  const user: User = { id: makeId('user'), email, name: input.name.trim(), created_at: now };
+  const organization: Organization = { id: makeId('org'), name: input.organization.trim(), created_at: now };
+  const membership: Membership = { id: makeId('membership'), user: user.id, organization: organization.id, role: 'owner', created_at: now };
+  const session: Session = { id: makeId('session'), user: user.id, created_at: now, expires_at: new Date(Date.now() + 86_400_000).toISOString() };
+  const event: AuditEvent = { id: makeId('event'), organization: organization.id, user: user.id, action: 'account.created', resource_type: 'User', resource_id: user.id, details: 'Initial organization and owner membership created', created_at: now };
+  await db.transaction(async transaction => {
+    transaction.collection<User>('User').insert(user, user.id, { requireAbsent: true });
+    transaction.collection<Organization>('Organization').insert(organization, organization.id, { requireAbsent: true });
+    transaction.collection<Membership>('Membership').insert(membership, membership.id, { requireAbsent: true });
+    transaction.collection<Session>('Session').insert(session, session.id, { requireAbsent: true });
+    transaction.collection<AuditEvent>('AuditEvent').insert(event, event.id, { requireAbsent: true });
+  }, { transactionId: makeId('signup') });
+  return session;
+}
+
+export async function createSession(emailInput: string) {
+  const user = (await users.find({ email: emailInput.trim().toLowerCase() }))[0];
+  if (!user) throw new Error('Account not found.');
+  const now = new Date().toISOString();
+  const session: Session = { id: makeId('session'), user: user.id, created_at: now, expires_at: new Date(Date.now() + 86_400_000).toISOString() };
+  await sessions.insert(session, session.id);
+  return session;
+}
+
+export async function createProject(input: { organization: string; owner: string; name: string }) {
+  const now = new Date().toISOString();
+  const project: Project = { id: makeId('project'), organization: input.organization, owner_id: input.owner, name: input.name.trim(), description: '', created_at: now, updated_at: now };
+  const event: AuditEvent = { id: makeId('event'), organization: input.organization, user: input.owner, action: 'project.created', resource_type: 'Project', resource_id: project.id, details: project.name, created_at: now };
+  await db.transaction(async transaction => {
+    transaction.collection<Project>('Project').insert(project, project.id, { requireAbsent: true });
+    transaction.collection<AuditEvent>('AuditEvent').insert(event, event.id, { requireAbsent: true });
+  });
+}
+
+export async function recordAgentActivity(input: { organization: string; user: string; assistant: string; subject: string }) {
+  const event: AuditEvent = { id: makeId('event'), organization: input.organization, user: input.user, action: 'agent.summary', resource_type: 'AgentExecution', resource_id: input.subject, details: `${input.assistant} summarized authorized application state`, created_at: new Date().toISOString() };
+  await auditEvents.insert(event, event.id);
+  return event;
+}

package/dist/create/template/default-project/src/index.tsx

@@ -0,0 +1,14 @@
+/**
+ * Application entry point
+ */
+
+import React from 'react';
+import ReactDOM from 'react-dom/client';
+import { App } from './App';
+
+const root = ReactDOM.createRoot(document.getElementById('root')!);
+root.render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>
+);

package/dist/create/template/default-project/src/pages/Activity.tsx

@@ -0,0 +1,7 @@
+import { useCollection } from '@feltdb/core/react';
+import { auditEvents } from '../feltdb';
+
+export function Activity() {
+  const state = useCollection(auditEvents);
+  return <section className="page"><div className="page-heading"><div><span className="eyebrow">Durable history</span><h1>Activity</h1><p>Workflow and agent actions land in the same application state.</p></div><span className="count">{state.data.length}</span></div><article className="panel records">{state.data.length ? state.data.slice().reverse().map(event => <div className="record" key={event.id}><span className="record-mark">↗</span><div><strong>{event.action}</strong><small>{event.details} · {new Date(event.created_at).toLocaleString()}</small></div></div>) : <div className="empty"><strong>No activity yet</strong><span>Create a project or run an assistant.</span></div>}</article></section>;
+}

package/dist/create/template/default-project/src/pages/Agents.tsx

@@ -0,0 +1,15 @@
+import { useMemo, useState } from 'react';
+import type { Capability } from '@feltdb/core';
+import { useCapability, useCollection } from '@feltdb/core/react';
+import { projects } from '../feltdb';
+import { useAuth } from '../context/AuthContext';
+import { runProjectAssistant } from '../../agents/project-assistant';
+import { runActivityAssistant } from '../../agents/activity-assistant';
+
+export function Agents() {
+  const { user, organization } = useAuth(); const projectState = useCollection(projects); const [projectId, setProjectId] = useState('');
+  const projectCapability = useMemo<Capability>(() => ({ id: 'run-project-assistant', name: 'Run Project Assistant', execute: () => runProjectAssistant({ projectId, organization: organization!.id, user: user!.id }) }), [projectId, organization, user]);
+  const activityCapability = useMemo<Capability>(() => ({ id: 'run-activity-assistant', name: 'Run Activity Assistant', execute: () => runActivityAssistant({ organization: organization!.id, user: user!.id }) }), [organization, user]);
+  const projectAgent = useCapability<[], { title: string; summary: string; activityCount: number }>(projectCapability); const activityAgent = useCapability<[], { summary: string; total: number }>(activityCapability);
+  return <section className="page"><div className="page-heading"><div><span className="eyebrow">Authorized agents</span><h1>Assistants</h1><p>Each assistant invokes bounded capabilities over the state you can already access.</p></div></div><div className="agent-grid"><article className="panel"><span className="agent-state">Project Assistant · project-summary</span><h2>Explain a project</h2><select value={projectId} onChange={event => setProjectId(event.target.value)}><option value="">Select a project</option>{projectState.data.map(project => <option key={project.id} value={project.id}>{project.name}</option>)}</select><button className="primary" disabled={!projectId || projectAgent.loading} onClick={() => void projectAgent.execute()}>{projectAgent.loading ? 'Running…' : 'Summarize project'}</button>{projectAgent.result && <div className="result"><strong>{projectAgent.result.title}</strong><p>{projectAgent.result.summary}</p><small>{projectAgent.result.activityCount} related activity events</small></div>}</article><article className="panel"><span className="agent-state">Activity Assistant · activity-summary</span><h2>Explain recent activity</h2><p className="muted">Reads authorized AuditEvent state and records its own execution.</p><button className="primary" disabled={activityAgent.loading} onClick={() => void activityAgent.execute()}>{activityAgent.loading ? 'Running…' : 'Summarize activity'}</button>{activityAgent.result && <div className="result"><p>{activityAgent.result.summary}</p></div>}</article></div></section>;
+}

package/dist/create/template/default-project/src/pages/Dashboard.tsx

@@ -0,0 +1,17 @@
+import { useState } from 'react';
+import { useCollection } from '@feltdb/core/react';
+import { auditEvents, invitations, projects, teams } from '../feltdb';
+import { useAuth } from '../context/AuthContext';
+import { Projects } from './Projects';
+import { Invitations } from './Invitations';
+import { Activity } from './Activity';
+import { Agents } from './Agents';
+
+type View = 'overview' | 'projects' | 'invitations' | 'activity' | 'agents';
+
+export function Dashboard() {
+  const { user, organization, signOut } = useAuth(); const [view, setView] = useState<View>('overview');
+  const projectState = useCollection(projects); const teamState = useCollection(teams); const invitationState = useCollection(invitations); const activityState = useCollection(auditEvents);
+  const stats = [{ label: 'Projects', value: projectState.data.length }, { label: 'Teams', value: teamState.data.length }, { label: 'Invitations', value: invitationState.data.filter(item => item.status === 'pending').length }, { label: 'Activity', value: activityState.data.length }];
+  return <main className="dashboard"><header><a className="brand" href="https://feltdb.com">FeltDB</a><nav>{(['overview', 'projects', 'invitations', 'activity', 'agents'] as View[]).map(item => <button className={view === item ? 'nav-active' : 'quiet'} onClick={() => setView(item)} key={item}>{item}</button>)}</nav><div><span>{user?.name}</span><button className="quiet" onClick={() => void signOut()}>Sign out</button></div></header>{view === 'overview' && <><section className="hero"><div><span className="eyebrow">{organization?.name}</span><h1>Welcome, {user?.name.split(' ')[0]}.</h1><p>State, workflows, and agents share one authorization boundary.</p></div><code>member · {organization?.id.slice(0, 12)}…</code></section><section className="stats">{stats.map(stat => <article key={stat.label}><span>{stat.label}</span><strong>{stat.value}</strong></article>)}</section><section className="grid"><article className="panel"><span className="eyebrow">Start here</span><h2>One application, visible in Studio</h2><div className="journey"><button onClick={() => setView('projects')}>1 <span>Create a project<small>Atomic Project + AuditEvent workflow</small></span></button><button onClick={() => setView('invitations')}>2 <span>Invite a member<small>Identity and relational authorization</small></span></button><button onClick={() => setView('agents')}>3 <span>Run an assistant<small>Bounded capabilities over authorized state</small></span></button></div></article><aside className="panel"><span className="eyebrow">Runtime</span><h2>One state boundary</h2><div className="stack"><div><i className="online" /><span>Application connected</span></div><div><i /><span>Authorization in FeltDB</span></div><div><i /><span>Workflows and agents persisted</span></div></div><p className="hint">Run <code>npm run feltdb:studio</code> to inspect the same records.</p></aside></section></>}{view === 'projects' && <Projects />}{view === 'invitations' && <Invitations />}{view === 'activity' && <Activity />}{view === 'agents' && <Agents />}</main>;
+}

package/dist/create/template/default-project/src/pages/Invitations.tsx

@@ -0,0 +1,11 @@
+import { useState, type FormEvent } from 'react';
+import { useCollection } from '@feltdb/core/react';
+import { invitations } from '../feltdb';
+import { useAuth } from '../context/AuthContext';
+import { runAcceptInvitationWorkflow, runInviteMemberWorkflow } from '../../workflows/invitation';
+
+export function Invitations() {
+  const { user, organization } = useAuth(); const state = useCollection(invitations); const [message, setMessage] = useState('');
+  async function invite(event: FormEvent<HTMLFormElement>) { event.preventDefault(); if (!user || !organization) return; const form = event.currentTarget; setMessage(''); try { await runInviteMemberWorkflow({ organization: organization.id, actor: user.id, email: String(new FormData(form).get('email')), role: 'member' }); form.reset(); } catch (error) { setMessage(error instanceof Error ? error.message : 'Invitation failed.'); } }
+  return <section className="page"><div className="page-heading"><div><span className="eyebrow">Invitation workflow</span><h1>Invitations</h1><p>Invitation visibility combines <code>self(user) | member</code>.</p></div><span className="count">{state.data.filter(item => item.status === 'pending').length}</span></div><article className="panel"><form className="project-form" onSubmit={invite}><input name="email" type="email" required placeholder="Existing user email" aria-label="Invite email" /><button>Invite member</button></form>{message && <p className="error">{message}</p>}<div className="records">{state.data.length ? state.data.slice().reverse().map(invitation => <div className="record spread" key={invitation.id}><div><strong>{invitation.email}</strong><small>{invitation.role} · {invitation.status}</small></div>{invitation.user === user?.id && invitation.status === 'pending' && <button onClick={() => void runAcceptInvitationWorkflow(invitation, user.id)}>Accept</button>}</div>) : <div className="empty"><strong>No invitations yet</strong><span>For this starter, invite another user who has already signed up.</span></div>}</div></article></section>;
+}

package/dist/create/template/default-project/src/pages/Projects.tsx

@@ -0,0 +1,11 @@
+import { useState, type FormEvent } from 'react';
+import { useCollection } from '@feltdb/core/react';
+import { projects } from '../feltdb';
+import { useAuth } from '../context/AuthContext';
+import { runProjectCreatedWorkflow } from '../../workflows/project-created';
+
+export function Projects() {
+  const { user, organization } = useAuth(); const state = useCollection(projects); const [busy, setBusy] = useState(false);
+  async function submit(event: FormEvent<HTMLFormElement>) { event.preventDefault(); if (!user || !organization) return; const form = event.currentTarget; setBusy(true); await runProjectCreatedWorkflow({ organization: organization.id, owner: user.id, name: String(new FormData(form).get('name')) }); form.reset(); setBusy(false); }
+  return <section className="page"><div className="page-heading"><div><span className="eyebrow">Project workflow</span><h1>Projects</h1><p>Creating a project atomically persists both Project and AuditEvent state.</p></div><span className="count">{state.data.length}</span></div><article className="panel"><form className="project-form" onSubmit={submit}><input name="name" required placeholder="A new project" aria-label="Project name" /><button disabled={busy}>{busy ? 'Running workflow…' : 'Create project'}</button></form><div className="records">{state.data.length ? state.data.slice().reverse().map(project => <div className="record" key={project.id}><span className="record-mark">{project.name.charAt(0).toUpperCase()}</span><div><strong>{project.name}</strong><small>ProjectCreated workflow · {new Date(project.created_at).toLocaleDateString()}</small></div></div>) : <div className="empty"><strong>No projects yet</strong><span>Create one to produce your first workflow state.</span></div>}</div></article></section>;
+}

package/dist/create/template/default-project/src/pages/SignIn.tsx

@@ -0,0 +1,8 @@
+import { useState, type FormEvent } from 'react';
+import { useAuth } from '../context/AuthContext';
+
+export function SignIn() {
+  const { signIn } = useAuth(); const [error, setError] = useState(''); const [busy, setBusy] = useState(false);
+  async function submit(event: FormEvent<HTMLFormElement>) { event.preventDefault(); setBusy(true); setError(''); const form = new FormData(event.currentTarget); try { await signIn(String(form.get('email')), String(form.get('password'))); } catch { setError('Those credentials could not be verified.'); setBusy(false); } }
+  return <><span className="eyebrow">Welcome back</span><h2>Sign in to FeltDB.</h2><p className="muted">Managed apps exchange credentials for a short-lived, application-scoped actor session.</p><form onSubmit={submit}><label>Email<input name="email" type="email" autoComplete="email" required placeholder="ada@example.com" /></label><label>Password<input name="password" type="password" autoComplete="current-password" required /></label>{error && <p className="error">{error}</p>}<button disabled={busy}>{busy ? 'Signing in…' : 'Sign in'}</button></form><p className="switch">New to this app? <a href="?view=signup">Create an account</a></p></>;
+}

package/dist/create/template/default-project/src/pages/SignUp.tsx

@@ -0,0 +1,8 @@
+import { useState, type FormEvent } from 'react';
+import { useAuth } from '../context/AuthContext';
+
+export function SignUp() {
+  const { signUp } = useAuth(); const [error, setError] = useState(''); const [busy, setBusy] = useState(false);
+  async function submit(event: FormEvent<HTMLFormElement>) { event.preventDefault(); setBusy(true); setError(''); const form = new FormData(event.currentTarget); try { await signUp({ name: String(form.get('name')), email: String(form.get('email')), password: String(form.get('password')), organization: String(form.get('organization')) }); } catch { setError('We could not create your account. Check the details and try again.'); setBusy(false); } }
+  return <><span className="eyebrow">Create your workspace</span><h2>Start with durable state.</h2><p className="muted">Your actor, account, and organization are established at the FeltDB boundary.</p><form onSubmit={submit}><label>Name<input name="name" autoComplete="name" required placeholder="Ada Lovelace" /></label><label>Work email<input name="email" type="email" autoComplete="email" required placeholder="ada@example.com" /></label><label>Password<input name="password" type="password" autoComplete="new-password" minLength={8} required /></label><label>Organization<input name="organization" required placeholder="Analytical Engines" /></label>{error && <p className="error">{error}</p>}<button disabled={busy}>{busy ? 'Creating…' : 'Create account'}</button></form><p className="switch">Already have an account? <a href="?view=signin">Sign in</a></p></>;
+}

package/dist/create/template/default-project/src/styles-application.css

@@ -0,0 +1,21 @@
+.dashboard header nav { display: flex; gap: .15rem; }
+.dashboard header nav button { text-transform: capitalize; }
+.nav-active { background: #dff0e5; color: #17633b; border-radius: 6px; padding: .5rem .7rem; }
+.page { padding: clamp(3rem, 7vw, 6rem) 0; }
+.page-heading { display: flex; justify-content: space-between; align-items: end; margin-bottom: 2rem; }
+.page-heading h1 { font: 500 clamp(3rem, 6vw, 5rem)/1 Georgia, serif; letter-spacing: -.055em; margin: .6rem 0; }
+.page-heading p { color: #68746d; }
+.count { font: 500 3rem Georgia, serif; color: #268453; }
+.journey { display: grid; margin-top: 1.5rem; }
+.journey button { display: flex; gap: 1rem; text-align: left; background: transparent; border-top: 1px solid #dedfd9; padding: 1.1rem .2rem; color: #268453; font-weight: 800; }
+.journey button span { display: grid; gap: .25rem; color: #102019; }
+.journey small { font-weight: 400; }
+.spread { justify-content: space-between; }
+.spread button { background: #dff0e5; color: #17633b; border-radius: 6px; padding: .55rem .8rem; }
+.agent-grid { display: grid; grid-template-columns: repeat(2, 1fr); gap: 1rem; }
+.agent-grid select { width: 100%; padding: .85rem; border: 1px solid #ccd2cd; border-radius: 8px; background: #fff; margin: 1rem 0; }
+.primary { display: block; width: 100%; padding: .85rem; border-radius: 8px; background: #102019; color: #fff; font-weight: 700; }
+.agent-state { font: 700 .68rem ui-monospace, monospace; color: #268453; text-transform: uppercase; }
+.result { margin-top: 1rem; padding: 1rem; border-radius: 8px; background: #eef3ee; line-height: 1.5; }
+@media (max-width: 900px) { .dashboard header nav { display: none; } }
+@media (max-width: 800px) { .agent-grid { grid-template-columns: 1fr; } }

package/dist/create/template/default-project/src/styles.css

@@ -0,0 +1 @@
+:root{font-family:Inter,ui-sans-serif,system-ui,sans-serif;color:#102019;background:#f4f3ed;font-synthesis:none}*{box-sizing:border-box}body{margin:0}a{color:inherit}button,input{font:inherit}button{border:0;cursor:pointer}.brand{font-weight:800;font-size:1.2rem;text-decoration:none;letter-spacing:-.04em}.auth-layout{min-height:100vh;display:grid;grid-template-columns:minmax(0,1.25fr) minmax(380px,.75fr)}.intro{padding:clamp(2rem,6vw,6rem);background:#102019;color:#f8f7f1;display:flex;flex-direction:column;justify-content:space-between}.intro h1{max-width:730px;font:500 clamp(3rem,6vw,6.5rem)/.98 Georgia,serif;letter-spacing:-.055em;margin:.8rem 0 1.5rem}.intro p{max-width:590px;color:#bdc9c1;font-size:1.08rem;line-height:1.65}.flow{display:flex;gap:1rem;color:#9eb0a5;font:600 .73rem ui-monospace,monospace;text-transform:uppercase;letter-spacing:.12em}.flow i{color:#49c17d}.auth-card{background:#fbfaf5;padding:clamp(2rem,6vw,6rem);display:flex;flex-direction:column;justify-content:center}h2{font:500 2rem/1.1 Georgia,serif;letter-spacing:-.035em;margin:.7rem 0}.muted,.switch{color:#68746d;line-height:1.55}form{display:grid;gap:1rem;margin:2rem 0 1.5rem}label{display:grid;gap:.45rem;font-weight:650;font-size:.8rem}input{width:100%;border:1px solid #ccd2cd;border-radius:8px;padding:.85rem 1rem;background:#fff;color:#102019}input:focus{outline:2px solid #49c17d;outline-offset:1px}form button,.project-form button{border-radius:8px;padding:.9rem 1.1rem;background:#102019;color:#fff;font-weight:700}button:disabled{opacity:.55}.eyebrow{color:#268453;font:700 .7rem ui-monospace,monospace;letter-spacing:.13em;text-transform:uppercase}.intro .eyebrow{color:#64dd98}.error{color:#a42c2c;font-size:.85rem}.switch{font-size:.85rem}.center{min-height:100vh;display:grid;place-content:center;text-align:center;color:#68746d}.loader{width:24px;height:24px;margin:auto;border:2px solid #cbd2cc;border-top-color:#268453;border-radius:50%;animation:spin .8s linear infinite}@keyframes spin{to{transform:rotate(360deg)}}.dashboard{min-height:100vh;padding:0 clamp(1.25rem,5vw,5rem) 5rem}.dashboard header{height:80px;display:flex;align-items:center;justify-content:space-between;border-bottom:1px solid #d5d7d1}.dashboard header>div{display:flex;gap:1.2rem;align-items:center;font-size:.85rem}.quiet{background:transparent;color:#68746d;padding:.5rem}.hero{padding:clamp(3rem,7vw,6.5rem) 0 3rem;display:flex;justify-content:space-between;align-items:end;gap:2rem}.hero h1{font:500 clamp(3rem,7vw,6rem)/1 Georgia,serif;letter-spacing:-.055em;margin:.7rem 0 1rem}.hero p{color:#68746d}code{font:.72rem ui-monospace,monospace;color:#26784e}.stats{display:grid;grid-template-columns:repeat(4,1fr);border:1px solid #d5d7d1;border-radius:12px;overflow:hidden;background:#faf9f4}.stats article{padding:1.3rem;border-right:1px solid #d5d7d1;display:grid;gap:.45rem}.stats article:last-child{border:0}.stats span{color:#68746d;font-size:.75rem}.stats strong{font:500 2rem Georgia,serif}.grid{display:grid;grid-template-columns:1.6fr .8fr;gap:1rem;margin-top:1rem}.panel{background:#faf9f4;border:1px solid #d5d7d1;border-radius:12px;padding:1.5rem}.panel-title{display:flex;align-items:start;justify-content:space-between}.panel-title>span{color:#68746d;font-size:.75rem}.project-form{grid-template-columns:1fr auto;margin:1.4rem 0}.records{display:grid;gap:.6rem}.record{padding:.8rem;border-top:1px solid #e1e1db;display:flex;align-items:center;gap:.8rem}.record-mark{width:36px;height:36px;border-radius:8px;display:grid;place-items:center;background:#dff0e5;color:#26784e;font-weight:800}.record div{display:grid;gap:.2rem}small{color:#7b857f}.empty{min-height:110px;display:grid;place-content:center;text-align:center;gap:.35rem;color:#68746d}.empty strong{color:#102019}.stack{display:grid;gap:1rem;margin:2rem 0}.stack div{display:flex;gap:.7rem;font-size:.85rem}.stack i{width:8px;height:8px;margin-top:.3rem;border-radius:50%;background:#9aa49d}.stack .online{background:#39ad6b;box-shadow:0 0 0 4px #dff0e5}.hint{color:#68746d;font-size:.85rem;line-height:1.6}@media(max-width:800px){.auth-layout,.grid{grid-template-columns:1fr}.intro{min-height:52vh;gap:3rem}.stats{grid-template-columns:repeat(2,1fr)}.stats article:nth-child(2){border-right:0}.hero{align-items:start;flex-direction:column}}

package/dist/create/template/default-project/workflows/agent-assisted-summary.ts

@@ -0,0 +1 @@
+export { runProjectAssistant as runAgentAssistedSummaryWorkflow } from '../agents/project-assistant';

package/dist/create/template/default-project/workflows/invitation.ts

@@ -0,0 +1,30 @@
+import { auditEvents, db, invitations, memberships, users, type AuditEvent, type Invitation, type Membership } from '../src/feltdb';
+
+const makeId = (prefix: string) => `${prefix}_${crypto.randomUUID()}`;
+
+export async function runInviteMemberWorkflow(input: { organization: string; actor: string; email: string; role: string }) {
+  const invited = (await users.find({ email: input.email.trim().toLowerCase() }))[0];
+  if (!invited) throw new Error('Invite an existing application user in this starter.');
+  const now = new Date().toISOString();
+  const invitation: Invitation = { id: makeId('invitation'), organization: input.organization, user: invited.id, email: invited.email, role: input.role, status: 'pending', created_at: now, updated_at: now };
+  const event: AuditEvent = { id: makeId('event'), organization: input.organization, user: input.actor, action: 'invitation.created', resource_type: 'Invitation', resource_id: invitation.id, details: invited.email, created_at: now };
+  await db.transaction(async transaction => {
+    transaction.collection<Invitation>('Invitation').insert(invitation, invitation.id, { requireAbsent: true });
+    transaction.collection<AuditEvent>('AuditEvent').insert(event, event.id, { requireAbsent: true });
+  });
+  return invitation;
+}
+
+export async function runAcceptInvitationWorkflow(invitation: Invitation, userId: string) {
+  if (invitation.user !== userId || invitation.status !== 'pending') throw new Error('This invitation cannot be accepted by the current identity.');
+  const now = new Date().toISOString();
+  const membership: Membership = { id: makeId('membership'), user: userId, organization: invitation.organization, role: invitation.role as Membership['role'], created_at: now };
+  const accepted = { ...invitation, status: 'accepted', updated_at: now };
+  const event: AuditEvent = { id: makeId('event'), organization: invitation.organization, user: userId, action: 'invitation.accepted', resource_type: 'Invitation', resource_id: invitation.id, details: membership.role, created_at: now };
+  await db.transaction(async transaction => {
+    transaction.collection<Invitation>('Invitation').insert(accepted, invitation.id);
+    transaction.collection<Membership>('Membership').insert(membership, membership.id, { requireAbsent: true });
+    transaction.collection<AuditEvent>('AuditEvent').insert(event, event.id, { requireAbsent: true });
+  });
+  return membership;
+}

package/dist/create/template/default-project/workflows/project-created.ts

@@ -0,0 +1,2 @@
+// Project and AuditEvent are committed atomically by the canonical operation.
+export { createProject as runProjectCreatedWorkflow } from '../src/feltdb';

package/dist/db.d.ts

@@ -29,7 +29,9 @@ interface FeltDBBaseOptions {
 export type FeltDBOptions = FeltDBBaseOptions & ({
     server: {
         url: string;
-        token: string;
+        token?: string;
+        applicationId?: string;
+        environment?: string;
     };
     memory?: never;
     path?: never;
@@ -250,6 +252,7 @@ export declare class StateFirstDB {
     private capabilityWorkers;
     private observation?;
     private closeDevelopmentBridge?;
+    private localActorSession?;
     readonly workloads: WorkloadClient;
     readonly artifacts: ArtifactClient;
     readonly bundle: BundleClient;
@@ -259,7 +262,52 @@ export declare class StateFirstDB {
     readonly workers: WorkerClient;
     readonly workerPools: WorkerPoolClient;
     readonly mesh: MeshClient;
+    readonly workflows: {
+        run: (name: string, input?: unknown, options?: {
+            idempotencyKey?: string;
+        }) => Promise<unknown>;
+    };
+    readonly agents: {
+        run: (name: string, input?: unknown, options?: {
+            idempotencyKey?: string;
+            goal?: string;
+        }) => Promise<unknown>;
+    };
+    readonly capabilities: {
+        run: <T = unknown>(name: string, input?: unknown, options?: {
+            idempotencyKey?: string;
+        }) => Promise<T>;
+    };
+    readonly application: {
+        get: () => Promise<Record<string, unknown> | {
+            application_id: any;
+            environment: string;
+            version: any;
+            contract_hash: string;
+            dsl_version: number;
+            snapshot: import("./application-development.js").FeltDBContractSnapshot;
+        }>;
+    };
+    readonly schema: {
+        get: () => Promise<Record<string, unknown>>;
+    };
+    readonly auth: {
+        signUp: (input: {
+            email: string;
+            password: string;
+            display_name?: string;
+        }) => Promise<any>;
+        signIn: (input: {
+            email: string;
+            password: string;
+        }) => Promise<any>;
+        signOut: () => Promise<any>;
+        session: () => Promise<any>;
+    };
     constructor(jsDb: JsDb, observation?: DevelopmentObservationSink, closeDevelopmentBridge?: () => Promise<void>);
+    private applicationRequest;
+    private authRequest;
+    private localAuthRequest;
     /**
      * Detect runtime environment and storage characteristics
      */