@protoyard/player 0.0.0-stage → 1.1.1

package/dist/boot/archetypes/business/SaasApp.svelte

@@ -0,0 +1,46 @@
+<script lang="ts">
+import type { AppModel, Blueprint } from '@protoyard/blueprint';
+import { getRuntime } from '@protoyard/renderer-svelte';
+import { createBilling } from '@protoyard/saas';
+import { provideSaas, saasRoutes } from '@protoyard/saas-ui';
+import { type Component, untrack } from 'svelte';
+import { createBusinessAdapter } from './adapter.js';
+import { PLAYER_BILLING_PLANS } from './definition.js';
+import { withArchetypeNav } from './nav.js';
+
+/**
+ * The blueprint's app with the SaaS kit: sign-up and sign-in, the onboarding
+ * wizard at the archetype's route, invitations, an inbox and simulated
+ * billing, all lazy kit routes. Settings and members stay the blueprint's.
+ */
+let {
+  blueprint,
+  model,
+  themeLibrary,
+  BlueprintApp,
+}: {
+  blueprint: Blueprint;
+  model: AppModel;
+  themeLibrary?: () => Promise<{ id: string; name: string }[]>;
+  // biome-ignore lint/suspicious/noExplicitAny: the crud app component is passed through.
+  BlueprintApp: Component<any>;
+} = $props();
+
+const runtime = getRuntime();
+// The kit context and routes are fixed for the app's lifetime (BlueprintApp reads them once).
+const adapter = untrack(() => createBusinessAdapter(blueprint));
+provideSaas(runtime, {
+  lazy: true,
+  onboardingPath: adapter.path,
+  billing: createBilling(runtime, PLAYER_BILLING_PLANS),
+});
+const extraRoutes = saasRoutes({
+  session: runtime.session,
+  lazy: true,
+  onboardingPath: adapter.path,
+  include: ['auth', 'onboarding', 'billing', 'invites', 'inbox'],
+});
+const appModel = $derived(withArchetypeNav(model, adapter));
+</script>
+
+<BlueprintApp {blueprint} model={appModel} {themeLibrary} {extraRoutes} />

package/dist/boot/archetypes/business/SaasApp.svelte.d.ts

@@ -0,0 +1,14 @@
+import type { AppModel, Blueprint } from '@protoyard/blueprint';
+import { type Component } from 'svelte';
+type $$ComponentProps = {
+    blueprint: Blueprint;
+    model: AppModel;
+    themeLibrary?: () => Promise<{
+        id: string;
+        name: string;
+    }[]>;
+    BlueprintApp: Component<any>;
+};
+declare const SaasApp: Component<$$ComponentProps, {}, "">;
+type SaasApp = ReturnType<typeof SaasApp>;
+export default SaasApp;

package/dist/boot/archetypes/business/adapter.d.ts

@@ -0,0 +1,45 @@
+import type { Blueprint, BlueprintArchetype, ScreenNavIcon } from '@protoyard/blueprint';
+/**
+ * Business archetypes in the player (ADR-032): `saas-onboarding` and
+ * `analytics`. They keep the blueprint's whole CRUD app and add the kit's
+ * screens as extra routes, so the archetype is a destination in the same app,
+ * not a replacement for it. This module only reads the validated archetype
+ * block; it imports no kit.
+ */
+export type BusinessArchetype = Extract<BlueprintArchetype, {
+    id: 'saas-onboarding' | 'analytics';
+}>;
+export interface AnalyticsFields {
+    eventEntity: string;
+    metricEntity: string;
+    /** A `datetime` or `date` field the dashboard buckets by (`createdAt` without one). */
+    dateField: string;
+    /** An `enum` field the dashboard breaks events down by, when there is one. */
+    typeField: string | null;
+    typeValues: readonly string[];
+    /** A `money`, `number` or `integer` field the dashboard sums, when there is one. */
+    valueField: string | null;
+    valueUnit: 'cents' | 'number';
+    /** The value field's label for its KPI tile (`Revenue`). */
+    valueLabel: string;
+    metricNameField: string;
+    metricValueField: string | null;
+}
+export interface BusinessAdapter {
+    readonly id: BusinessArchetype['id'];
+    /** The kit screen's route (`/onboarding`, `/analytics`). */
+    readonly path: string;
+    readonly navLabel: string;
+    readonly navIcon: ScreenNavIcon;
+    /** Present for `analytics`. */
+    readonly analytics: AnalyticsFields | null;
+    /** Present for `saas-onboarding`: the blueprint entities the kit's workspace and member slots name. */
+    readonly saas: {
+        workspaceEntity: string;
+        memberEntity: string;
+    } | null;
+}
+export declare function isBusinessArchetype(blueprint: Blueprint): blueprint is Blueprint & {
+    archetype: BusinessArchetype;
+};
+export declare function createBusinessAdapter(blueprint: Blueprint): BusinessAdapter;

package/dist/boot/archetypes/business/adapter.js

@@ -0,0 +1,64 @@
+export function isBusinessArchetype(blueprint) {
+    const id = blueprint.archetype?.id;
+    return id === 'saas-onboarding' || id === 'analytics';
+}
+function entity(blueprint, name) {
+    const found = blueprint.entities.find((candidate) => candidate.name === name);
+    if (!found)
+        throw new Error(`The archetype names an unknown entity "${name}".`);
+    return found;
+}
+function analyticsFields(blueprint, slots) {
+    const events = entity(blueprint, slots.events);
+    const metrics = entity(blueprint, slots.metrics);
+    const date = events.fields.find((field) => field.kind === 'datetime') ??
+        events.fields.find((field) => field.kind === 'date');
+    const type = events.fields.find((field) => field.kind === 'enum');
+    const value = events.fields.find((field) => field.kind === 'money') ??
+        events.fields.find((field) => field.kind === 'number' || field.kind === 'integer');
+    const metricValue = metrics.fields.find((field) => field.kind === 'number' || field.kind === 'integer' || field.kind === 'money');
+    return {
+        eventEntity: events.name,
+        metricEntity: metrics.name,
+        dateField: date?.name ?? 'createdAt',
+        typeField: type?.name ?? null,
+        typeValues: type && 'values' in type ? type.values : [],
+        valueField: value?.name ?? null,
+        valueUnit: value?.kind === 'money' ? 'cents' : 'number',
+        valueLabel: value
+            ? (value.label ?? value.name.charAt(0).toUpperCase() + value.name.slice(1))
+            : 'Value',
+        metricNameField: metrics.titleField,
+        metricValueField: metricValue?.name ?? null,
+    };
+}
+export function createBusinessAdapter(blueprint) {
+    if (!isBusinessArchetype(blueprint)) {
+        throw new Error('The player business adapter needs a saas-onboarding or analytics archetype.');
+    }
+    const archetype = blueprint.archetype;
+    const path = archetype.screens[0].path;
+    if (archetype.id === 'analytics') {
+        return {
+            id: 'analytics',
+            path,
+            navLabel: 'Analytics',
+            navIcon: 'chart-line',
+            analytics: analyticsFields(blueprint, archetype.entities),
+            saas: null,
+        };
+    }
+    entity(blueprint, archetype.entities.workspaces);
+    entity(blueprint, archetype.entities.members);
+    return {
+        id: 'saas-onboarding',
+        path,
+        navLabel: 'Get started',
+        navIcon: 'zap',
+        analytics: null,
+        saas: {
+            workspaceEntity: archetype.entities.workspaces,
+            memberEntity: archetype.entities.members,
+        },
+    };
+}

package/dist/boot/archetypes/business/analytics.d.ts

@@ -0,0 +1,2 @@
+/** Lazy entry for the analytics archetype; the dashboard itself loads with its route. */
+export { default as AnalyticsApp } from './AnalyticsApp.svelte';

package/dist/boot/archetypes/business/analytics.js

@@ -0,0 +1,2 @@
+/** Lazy entry for the analytics archetype; the dashboard itself loads with its route. */
+export { default as AnalyticsApp } from './AnalyticsApp.svelte';

package/dist/boot/archetypes/business/definition.d.ts

@@ -0,0 +1,26 @@
+import type { Blueprint } from '@protoyard/blueprint';
+import type { PrototypeDefinition } from '@protoyard/core';
+export declare function withSaasKit(definition: PrototypeDefinition, blueprint: Blueprint): PrototypeDefinition;
+/** Plans for the simulated billing screens (integer cents per seat; no card, no charge). */
+export declare const PLAYER_BILLING_PLANS: readonly [{
+    readonly id: "starter";
+    readonly name: "Starter";
+    readonly unitAmountCents: 0;
+    readonly currency: "USD";
+    readonly interval: "month";
+    readonly trialDays: 14;
+}, {
+    readonly id: "team";
+    readonly name: "Team";
+    readonly unitAmountCents: 1200;
+    readonly currency: "USD";
+    readonly interval: "month";
+    readonly trialDays: 14;
+}, {
+    readonly id: "business";
+    readonly name: "Business";
+    readonly unitAmountCents: 4500;
+    readonly currency: "USD";
+    readonly interval: "month";
+    readonly trialDays: 14;
+}];

package/dist/boot/archetypes/business/definition.js

@@ -0,0 +1,127 @@
+import { BILLING_CAPABILITY, DEFAULT_ONBOARDING_CAPABILITY, generateSaasWorld, mergeIntegrity, SAAS_GENERATOR_VERSION, saasIntegrity, saasStores, WORKSPACE_CAPABILITIES, } from '@protoyard/saas';
+/**
+ * Adds the SaaS kit to a blueprint's runtime definition, the way
+ * docs/SAAS_KITS.md describes for a hand-written prototype:
+ *
+ * - the kit's `saas_*` stores in one more database version (the blueprint's
+ *   own versions are untouched, so existing worlds upgrade in place);
+ * - kit integrity merged with the blueprint's;
+ * - kit rows (accounts, invitations, inbox, billing) generated from the same
+ *   team the blueprint generator produced, after it, so worlds stay
+ *   deterministic;
+ * - the kit's self-service capabilities for every role, and workspace,
+ *   member and billing management for roles that may change the archetype's
+ *   workspace entity.
+ *
+ * Simulated: sign-in, invitations and billing are UX, never security or a
+ * real provider.
+ */
+const SELF_SERVICE = [
+    DEFAULT_ONBOARDING_CAPABILITY,
+    'profile:update',
+    'settings:notifications',
+    'settings:security',
+    WORKSPACE_CAPABILITIES.create,
+    WORKSPACE_CAPABILITIES.leave,
+];
+const MANAGE = [
+    BILLING_CAPABILITY,
+    'members:invite',
+    'members:transfer',
+    WORKSPACE_CAPABILITIES.rename,
+];
+function canManage(capabilities, workspaceEntity) {
+    return capabilities.some((capability) => capability === '*' ||
+        capability === `${workspaceEntity}:*` ||
+        capability === `${workspaceEntity}:update` ||
+        capability === '*:update');
+}
+export function withSaasKit(definition, blueprint) {
+    const archetype = blueprint.archetype;
+    if (archetype?.id !== 'saas-onboarding')
+        return definition;
+    const versions = definition.database.versions;
+    const last = versions[versions.length - 1]?.version ?? 0;
+    const version = last + 1;
+    const roles = Object.fromEntries(Object.entries(definition.policy?.roles ?? {}).map(([role, capabilities]) => [
+        role,
+        [
+            ...new Set([
+                ...capabilities,
+                ...SELF_SERVICE,
+                ...(canManage(capabilities, archetype.entities.workspaces) ? MANAGE : []),
+            ]),
+        ],
+    ]));
+    const baseGenerate = definition.generate;
+    // Kit rows need the runtime's GenerateContext (rng, faker, ids), so this
+    // archetype opts out of the context-free generateWorld path: the runtime
+    // then calls generate, whose base still generates in the worker.
+    const { generateWorld: _contextFree, ...rest } = definition;
+    return {
+        ...rest,
+        manifest: {
+            ...definition.manifest,
+            storage: { ...definition.manifest.storage, schemaVersion: version },
+        },
+        database: {
+            ...definition.database,
+            versions: [...versions, { version, stores: saasStores() }],
+        },
+        integrity: mergeIntegrity(definition.integrity, saasIntegrity()),
+        policy: { ...definition.policy, roles },
+        generatorVersion: ((definition.generatorVersion ?? 1) * 31 + SAAS_GENERATOR_VERSION) >>> 0,
+        async generate(ctx) {
+            const base = await baseGenerate(ctx);
+            const organization = base.organizations.find((candidate) => candidate.id === ctx.scenario.organization.id) ??
+                base.organizations[0];
+            const actor = base.personas.find((candidate) => candidate.id === ctx.scenario.actor.id) ??
+                base.personas[0];
+            if (!organization || !actor)
+                return base;
+            const saas = generateSaasWorld(ctx, {
+                team: {
+                    organizations: base.organizations,
+                    personas: base.personas,
+                    memberships: base.memberships,
+                    organization,
+                    actor,
+                },
+            });
+            return {
+                ...base,
+                organizations: saas.organizations,
+                personas: saas.personas,
+                memberships: saas.memberships,
+                tables: { ...base.tables, ...saas.tables },
+            };
+        },
+    };
+}
+/** Plans for the simulated billing screens (integer cents per seat; no card, no charge). */
+export const PLAYER_BILLING_PLANS = [
+    {
+        id: 'starter',
+        name: 'Starter',
+        unitAmountCents: 0,
+        currency: 'USD',
+        interval: 'month',
+        trialDays: 14,
+    },
+    {
+        id: 'team',
+        name: 'Team',
+        unitAmountCents: 1200,
+        currency: 'USD',
+        interval: 'month',
+        trialDays: 14,
+    },
+    {
+        id: 'business',
+        name: 'Business',
+        unitAmountCents: 4500,
+        currency: 'USD',
+        interval: 'month',
+        trialDays: 14,
+    },
+];

package/dist/boot/archetypes/business/metrics.d.ts

@@ -0,0 +1,27 @@
+import { type DateRange } from '@protoyard/analytics';
+import type { DateRangeValue } from '@protoyard/analytics-ui/date-range';
+import type { Row } from '@protoyard/core';
+import type { AnalyticsFields } from './adapter.ts';
+/**
+ * Pure dashboard numbers from event rows: the totals for the selected range,
+ * the same numbers for the comparison range, and a breakdown by type.
+ * Deterministic for the same rows, range and simulated "now".
+ */
+export interface DashboardNumbers {
+    range: DateRange;
+    previous: DateRange | null;
+    events: {
+        current: number;
+        previous: number | null;
+    };
+    value: {
+        current: number;
+        previous: number | null;
+    } | null;
+    byType: {
+        type: string;
+        count: number;
+        previous: number | null;
+    }[];
+}
+export declare function dashboardNumbers(rows: readonly Row[], fields: AnalyticsFields, value: DateRangeValue, now: number): DashboardNumbers;

package/dist/boot/archetypes/business/metrics.js

@@ -0,0 +1,38 @@
+import { comparisonRange, resolveDateRange } from '@protoyard/analytics';
+function timeOf(row, field) {
+    const raw = row[field];
+    if (typeof raw !== 'string')
+        return null;
+    const ms = Date.parse(raw);
+    return Number.isNaN(ms) ? null : ms;
+}
+const within = (rows, field, range) => rows.filter((row) => {
+    const at = timeOf(row, field);
+    return at !== null && at >= range.start && at < range.end;
+});
+const sum = (rows, field) => rows.reduce((total, row) => total + (typeof row[field] === 'number' ? row[field] : 0), 0);
+export function dashboardNumbers(rows, fields, value, now) {
+    const range = resolveDateRange(value.range, now);
+    const previous = comparisonRange(range, value.comparison);
+    const current = within(rows, fields.dateField, range);
+    const before = previous ? within(rows, fields.dateField, previous) : null;
+    const typeField = fields.typeField;
+    return {
+        range,
+        previous,
+        events: { current: current.length, previous: before ? before.length : null },
+        value: fields.valueField
+            ? {
+                current: sum(current, fields.valueField),
+                previous: before ? sum(before, fields.valueField) : null,
+            }
+            : null,
+        byType: typeField
+            ? fields.typeValues.map((type) => ({
+                type,
+                count: current.filter((row) => row[typeField] === type).length,
+                previous: before ? before.filter((row) => row[typeField] === type).length : null,
+            }))
+            : [],
+    };
+}

package/dist/boot/archetypes/business/nav.d.ts

@@ -0,0 +1,7 @@
+import type { AppModel } from '@protoyard/blueprint';
+import type { BusinessAdapter } from './adapter.ts';
+/**
+ * The app model with the archetype's screen in navigation: right after Home,
+ * and first in the Overview group, so the kit screen is one click away.
+ */
+export declare function withArchetypeNav(model: AppModel, adapter: BusinessAdapter): AppModel;

package/dist/boot/archetypes/business/nav.js

@@ -0,0 +1,19 @@
+/**
+ * The app model with the archetype's screen in navigation: right after Home,
+ * and first in the Overview group, so the kit screen is one click away.
+ */
+export function withArchetypeNav(model, adapter) {
+    if (model.nav.some((item) => item.path === adapter.path))
+        return model;
+    const item = { path: adapter.path, label: adapter.navLabel, icon: adapter.navIcon };
+    const [home, ...rest] = model.nav;
+    const groups = model.navGroups.map((group, index) => index === 0
+        ? { ...group, paths: [group.paths[0] ?? '/', adapter.path, ...group.paths.slice(1)] }
+        : group);
+    return {
+        ...model,
+        nav: home ? [home, item, ...rest] : [item],
+        navGroups: groups.length > 0 ? groups : [{ label: 'Overview', paths: [adapter.path] }],
+        icons: model.icons.includes(adapter.navIcon) ? model.icons : [...model.icons, adapter.navIcon],
+    };
+}

package/dist/boot/archetypes/business/saas.d.ts

@@ -0,0 +1,3 @@
+/** Lazy entry for the saas-onboarding archetype (SaaS engine and kit screens). */
+export { PLAYER_BILLING_PLANS, withSaasKit } from './definition.ts';
+export { default as SaasApp } from './SaasApp.svelte';

package/dist/boot/archetypes/business/saas.js

@@ -0,0 +1,3 @@
+/** Lazy entry for the saas-onboarding archetype (SaaS engine and kit screens). */
+export { PLAYER_BILLING_PLANS, withSaasKit } from "./definition.js";
+export { default as SaasApp } from './SaasApp.svelte';

package/dist/boot/archetypes/conversational/ConversationalApp.svelte

@@ -0,0 +1,108 @@
+<script lang="ts">
+import type { AssistantSendInput } from '@protoyard/ai-ui';
+import { type Blueprint, createEntityServices } from '@protoyard/blueprint';
+import { getRuntime, liveQuery } from '@protoyard/renderer-svelte';
+import { ErrorState, LoadingState } from '@protoyard/ui';
+import { createConversationalAdapter } from './adapter.js';
+import { scriptedReply } from './reply.js';
+
+let { blueprint }: { blueprint: Blueprint } = $props();
+const runtime = getRuntime();
+// Derived from the prop, so a different blueprint rebuilds the services and queries.
+const services = $derived(createEntityServices(runtime, blueprint));
+const adapter = $derived(createConversationalAdapter(blueprint));
+const conversationService = $derived(services[adapter.conversationEntity]);
+const messageService = $derived(services[adapter.messageEntity]);
+const memberService = $derived(adapter.memberEntity ? services[adapter.memberEntity] : undefined);
+
+const conversationRows = liveQuery(() => conversationService?.list() ?? Promise.resolve([]), {
+  initial: [],
+  deps: () => [conversationService],
+});
+const messageRows = liveQuery(() => messageService?.list() ?? Promise.resolve([]), {
+  initial: [],
+  deps: () => [messageService],
+});
+const memberRows = liveQuery(() => memberService?.list() ?? Promise.resolve([]), {
+  initial: [],
+  deps: () => [memberService],
+});
+const conversations = $derived(adapter.conversations(conversationRows.current ?? []));
+let selectedId = $state('');
+const actorId = $derived(memberRows.current?.[0] ? String(memberRows.current[0].id) : undefined);
+const messages = $derived(adapter.messages(messageRows.current ?? [], selectedId, actorId));
+const kit = import('@protoyard/ai-ui');
+
+$effect(() => {
+  if (!conversations.some((conversation) => conversation.id === selectedId)) {
+    selectedId = conversations[0]?.id ?? '';
+  }
+});
+
+async function send(conversationId: string, input: AssistantSendInput): Promise<boolean> {
+  if (!messageService) return false;
+  const prompt = input.prompt.trim();
+  if (!prompt) return false;
+  const now = runtime.clock.now().toISOString();
+  await messageService.create(adapter.messageInput(conversationId, prompt, now, 'user', actorId));
+  const reply = await scriptedReply(runtime, conversationId, prompt);
+  await messageService.create(
+    adapter.messageInput(conversationId, reply, runtime.clock.now().toISOString(), 'assistant')
+  );
+  return true;
+}
+
+async function rename(conversationId: string, title: string): Promise<void> {
+  if (!conversationService) return;
+  const clean = title.trim();
+  if (!clean) return;
+  await conversationService.update(
+    conversationId,
+    blueprint.archetype?.id === 'team-chat' ? { name: clean } : { title: clean }
+  );
+}
+
+function selectConversation(id: string): void {
+  selectedId = id;
+}
+</script>
+
+<!--
+  The CRUD app paints its surface through LayoutHost; this archetype has no layout,
+  so it paints the theme background itself (otherwise dark mode shows the browser's
+  white canvas behind dark-theme text).
+-->
+<div class="min-h-full bg-background text-foreground" data-testid="player-conversational-surface">
+  <section
+    class="mx-auto w-full max-w-7xl px-4 py-6 pb-safe sm:px-6 lg:px-8"
+    data-testid="player-conversational-archetype"
+    data-archetype={adapter.id}
+    data-route={adapter.path}
+  >
+    <div class="mb-4">
+      <p class="text-xs font-medium uppercase tracking-wide text-muted-foreground">{adapter.id === 'team-chat' ? 'Team chat' : 'Assistant workspace'} · Simulated</p>
+      <h1 class="text-2xl font-semibold">{blueprint.name}</h1>
+    </div>
+    {#if conversationRows.error || messageRows.error}
+      <ErrorState title="The conversation could not be loaded" message="The simulated conversation data is unavailable." />
+    {:else if conversationRows.loading || messageRows.loading}
+      <LoadingState label="Loading conversations" class="py-16" />
+    {:else}
+      {#await kit then { AssistantWorkspace }}
+        <AssistantWorkspace
+          {conversations}
+          {messages}
+          selectedConversationId={selectedId}
+          onSend={send}
+          onSelectConversation={selectConversation}
+          onRenameConversation={rename}
+        />
+      {:catch error}
+        <ErrorState
+          title="The conversational kit could not be loaded"
+          message={error instanceof Error ? error.message : String(error)}
+        />
+      {/await}
+    {/if}
+  </section>
+</div>

package/dist/boot/archetypes/conversational/ConversationalApp.svelte.d.ts

@@ -0,0 +1,7 @@
+import { type Blueprint } from '@protoyard/blueprint';
+type $$ComponentProps = {
+    blueprint: Blueprint;
+};
+declare const ConversationalApp: import("svelte").Component<$$ComponentProps, {}, "">;
+type ConversationalApp = ReturnType<typeof ConversationalApp>;
+export default ConversationalApp;

package/dist/boot/archetypes/conversational/adapter.d.ts

@@ -0,0 +1,24 @@
+import type { AssistantConversation, AssistantMessage } from '@protoyard/ai-ui';
+import type { Blueprint, BlueprintArchetype } from '@protoyard/blueprint';
+import type { Row } from '@protoyard/core';
+type ConversationalArchetype = Extract<BlueprintArchetype, {
+    id: 'assistant' | 'team-chat';
+}>;
+export interface ConversationalAdapter {
+    readonly id: ConversationalArchetype['id'];
+    readonly path: string;
+    readonly conversationEntity: string;
+    readonly messageEntity: string;
+    readonly memberEntity?: string;
+    readonly parentProperty: 'conversationId' | 'roomId';
+    readonly contentProperty: 'content' | 'body';
+    conversations(rows: readonly Row[]): AssistantConversation[];
+    messages(rows: readonly Row[], conversationId: string, actorId?: string): AssistantMessage[];
+    messageInput(conversationId: string, content: string, now: string, role: 'user' | 'assistant', actorId?: string): Record<string, unknown>;
+    conversationInput(title: string): Record<string, unknown>;
+}
+export declare function isConversationalArchetype(blueprint: Blueprint): blueprint is Blueprint & {
+    archetype: ConversationalArchetype;
+};
+export declare function createConversationalAdapter(blueprint: Blueprint): ConversationalAdapter;
+export {};

package/dist/boot/archetypes/conversational/adapter.js

@@ -0,0 +1,74 @@
+function text(row, property, fallback) {
+    const value = row[property];
+    return typeof value === 'string' && value.trim() ? value : fallback;
+}
+function timestamp(row) {
+    return text(row, 'updatedAt', text(row, 'createdAt', '1970-01-01T00:00:00.000Z'));
+}
+function idOf(row) {
+    return String(row.id);
+}
+export function isConversationalArchetype(blueprint) {
+    const id = blueprint.archetype?.id;
+    return id === 'assistant' || id === 'team-chat';
+}
+export function createConversationalAdapter(blueprint) {
+    if (!isConversationalArchetype(blueprint)) {
+        throw new Error('The player conversational adapter needs an assistant or team-chat archetype.');
+    }
+    const archetype = blueprint.archetype;
+    const teamChat = archetype.id === 'team-chat';
+    const conversationEntity = teamChat ? archetype.entities.rooms : archetype.entities.conversations;
+    const messageEntity = archetype.entities.messages;
+    const memberEntity = teamChat ? archetype.entities.members : undefined;
+    const parentProperty = teamChat ? 'roomId' : 'conversationId';
+    const contentProperty = teamChat ? 'body' : 'content';
+    return {
+        id: archetype.id,
+        path: archetype.screens[0].path,
+        conversationEntity,
+        messageEntity,
+        memberEntity,
+        parentProperty,
+        contentProperty,
+        conversations(rows) {
+            return rows.map((row) => ({
+                id: idOf(row),
+                title: text(row, teamChat ? 'name' : 'title', 'New conversation'),
+                updatedAt: timestamp(row),
+                ...(typeof row.pinned === 'boolean' ? { pinned: row.pinned } : {}),
+                ...(typeof row.folder === 'string' ? { folder: row.folder } : {}),
+            }));
+        },
+        messages(rows, conversationId, actorId) {
+            return rows
+                .filter((row) => String(row[parentProperty]) === conversationId)
+                .map((row) => ({
+                id: idOf(row),
+                role: teamChat && actorId
+                    ? String(row.authorId) === actorId
+                        ? 'user'
+                        : 'assistant'
+                    : row.role === 'user'
+                        ? 'user'
+                        : 'assistant',
+                content: text(row, contentProperty, ''),
+                createdAt: text(row, 'sentAt', timestamp(row)),
+            }));
+        },
+        messageInput(conversationId, content, now, role, actorId) {
+            if (teamChat) {
+                return {
+                    body: content,
+                    roomId: conversationId,
+                    sentAt: now,
+                    ...(actorId && role === 'user' ? { authorId: actorId } : {}),
+                };
+            }
+            return { content, role, conversationId, sentAt: now };
+        },
+        conversationInput(title) {
+            return teamChat ? { name: title, visibility: 'public' } : { title, status: 'active' };
+        },
+    };
+}

package/dist/boot/archetypes/conversational/index.d.ts

@@ -0,0 +1,4 @@
+/** Lazy conversational archetype entry: assistant and team-chat share the AI UI kit. */
+export { type ConversationalAdapter, createConversationalAdapter, isConversationalArchetype, } from './adapter.ts';
+export { default as ConversationalApp } from './ConversationalApp.svelte';
+export { scriptedReply } from './reply.ts';