@dxos/plugin-debug 0.12.0-next-73daef452f1464b62efdbca75fb0067c1066f264 → 0.13.0

package/src/samples/crm/PipelineSpace.ts

@@ -0,0 +1,52 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+// @import-as-namespace
+
+import * as Effect from 'effect/Effect';
+
+import type * as AppCapabilities from '@dxos/app-toolkit/AppCapabilities';
+import * as SampleSpace from '@dxos/app-toolkit/SampleSpace';
+
+import { Accounts, Contacts } from './accounts.ts';
+import { Inbox } from './inbox.ts';
+import { PipelineBoard } from './pipeline.ts';
+import { REFERENCE } from './util.ts';
+
+const phases = {
+  accounts: Accounts,
+  contacts: Contacts,
+  pipeline: PipelineBoard,
+  inbox: Inbox,
+};
+
+/**
+ * A CRM template: seven accounts spread across the pipeline stages, one named contact each, a
+ * board whose columns are views filtered on `Organization.status`, and the mail thread behind each
+ * stage.
+ *
+ * Nothing is filed into a collection: Organization, Person, Pipeline and Mailbox are not
+ * collection-item types, so they live directly in the space DB and surface through their own
+ * containers and the database viewer.
+ */
+export const make = (): SampleSpace.Definition<typeof phases, void> =>
+  SampleSpace.make({
+    space: { name: 'Northwind Sales', icon: 'handshake', hue: 'purple' },
+    reference: REFERENCE,
+    phases,
+    build: (phases) =>
+      Effect.gen(function* () {
+        const accounts = yield* phases.accounts();
+        yield* phases.contacts(accounts);
+        yield* phases.pipeline(accounts);
+        yield* phases.inbox();
+      }),
+  });
+
+export const makeTemplate = (): AppCapabilities.SpaceTemplate =>
+  SampleSpace.makeTemplate({
+    id: 'org.dxos.plugin-debug.template.pipeline',
+    description: 'Seven accounts across the pipeline stages, a contact each, and the mail behind them.',
+    definition: make(),
+  });

package/src/samples/crm/accounts.ts

@@ -0,0 +1,153 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as SampleSpace from '@dxos/app-toolkit/SampleSpace';
+import { Database, Ref } from '@dxos/echo';
+import { Organization, Person } from '@dxos/types';
+
+//
+// Accounts and the people at them. `status` is the pipeline stage: every column of the board is a
+// view filtered on it, so the seeds here are what the board is a picture of.
+//
+
+export type AccountKey = 'meridian' | 'bellweather' | 'foxglove' | 'northgate' | 'quarry' | 'saltbox' | 'tinderbox';
+
+export type AccountMap = Record<AccountKey, Organization.Organization>;
+
+const ACCOUNT_SEEDS = [
+  {
+    key: 'meridian',
+    name: 'Meridian Health',
+    description: 'Renewed for a third year. Two hundred seats, expanding into their research arm.',
+    status: 'active',
+    website: 'https://meridianhealth.example',
+  },
+  {
+    key: 'bellweather',
+    name: 'Bellweather Logistics',
+    description: 'Signed in March. Rolling out to dispatch first, then the depots.',
+    status: 'active',
+    website: 'https://bellweather.example',
+  },
+  {
+    key: 'foxglove',
+    name: 'Foxglove Studios',
+    description: 'Verbal yes on a 40-seat plan; waiting on their finance sign-off.',
+    status: 'commit',
+    website: 'https://foxglove.example',
+  },
+  {
+    key: 'northgate',
+    name: 'Northgate Credit Union',
+    description: 'Security review passed. Procurement is the only thing left.',
+    status: 'commit',
+    website: 'https://northgatecu.example',
+  },
+  {
+    key: 'quarry',
+    name: 'Quarry Analytics',
+    description: 'Pilot running with eight users. Champion is the head of data.',
+    status: 'qualified',
+    website: 'https://quarry.example',
+  },
+  {
+    key: 'saltbox',
+    name: 'Saltbox Provisions',
+    description: 'Inbound from the newsletter. Budget unclear, timeline unclear.',
+    status: 'prospect',
+    website: 'https://saltbox.example',
+  },
+  {
+    key: 'tinderbox',
+    name: 'Tinderbox Media',
+    description: 'Went quiet after the second call. Re-engage next quarter, or close it out.',
+    status: 'reject',
+    website: 'https://tinderbox.example',
+  },
+] as const;
+
+/** The accounts, each already at its pipeline stage. */
+export const Accounts: SampleSpace.Phase<AccountMap> = SampleSpace.phase('accounts', {
+  schemas: [Organization.Organization],
+  run: () =>
+    SampleSpace.seed(ACCOUNT_SEEDS, (seed) =>
+      Database.add(
+        Organization.make({
+          name: seed.name,
+          description: seed.description,
+          status: seed.status,
+          website: seed.website,
+        }),
+      ),
+    ),
+});
+
+export type ContactKey = 'dara' | 'wes' | 'ines' | 'gil' | 'mo' | 'ruth' | 'jonas';
+
+export type ContactMap = Record<ContactKey, Person.Person>;
+
+const CONTACT_SEEDS = [
+  {
+    key: 'dara',
+    fullName: 'Dara Osei',
+    jobTitle: 'Director of IT',
+    accountKey: 'meridian',
+    email: 'dara.osei@meridianhealth.example',
+  },
+  {
+    key: 'wes',
+    fullName: 'Wes Kowalski',
+    jobTitle: 'Head of Dispatch',
+    accountKey: 'bellweather',
+    email: 'wes@bellweather.example',
+  },
+  {
+    key: 'ines',
+    fullName: 'Inés Baptista',
+    jobTitle: 'Studio Producer',
+    accountKey: 'foxglove',
+    email: 'ines@foxglove.example',
+  },
+  {
+    key: 'gil',
+    fullName: 'Gil Ferreira',
+    jobTitle: 'CISO',
+    accountKey: 'northgate',
+    email: 'g.ferreira@northgatecu.example',
+  },
+  { key: 'mo', fullName: 'Mo Haddad', jobTitle: 'Head of Data', accountKey: 'quarry', email: 'mo@quarry.example' },
+  { key: 'ruth', fullName: 'Ruth Lindqvist', jobTitle: 'Owner', accountKey: 'saltbox', email: 'ruth@saltbox.example' },
+  {
+    key: 'jonas',
+    fullName: 'Jonas Vail',
+    jobTitle: 'Creative Director',
+    accountKey: 'tinderbox',
+    email: 'jonas@tinderbox.example',
+  },
+] as const;
+
+/** One named contact per account — whoever the mail in this space is actually with. */
+export const Contacts: SampleSpace.Phase<ContactMap, AccountMap> = SampleSpace.phase('contacts', {
+  schemas: [Person.Person],
+  run: (accounts: AccountMap) =>
+    SampleSpace.seed(CONTACT_SEEDS, (seed) =>
+      Database.add(
+        Person.make({
+          fullName: seed.fullName,
+          jobTitle: seed.jobTitle,
+          organization: Ref.make(accounts[seed.accountKey]),
+          emails: [{ label: 'Work', value: seed.email }],
+        }),
+      ),
+    ),
+});
+
+/** Contact seeds, for the phases that need a name and address rather than the object. */
+export const contactSeed = (key: ContactKey) => {
+  const seed = CONTACT_SEEDS.find((seed) => seed.key === key);
+  if (!seed) {
+    throw new Error(`No CONTACT_SEEDS entry for "${key}".`);
+  }
+  return seed;
+};

package/src/samples/crm/inbox.ts

@@ -0,0 +1,158 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import * as SampleSpace from '@dxos/app-toolkit/SampleSpace';
+import { Database, Feed, Obj, Tag } from '@dxos/echo';
+import * as Mailbox from '@dxos/plugin-inbox/Mailbox';
+import * as SystemTags from '@dxos/plugin-inbox/SystemTags';
+import { TagIndex } from '@dxos/schema';
+import { type Actor, type ContentBlock, Message } from '@dxos/types';
+
+import { type ContactKey, contactSeed } from './accounts.ts';
+import { daysAgo } from './util.ts';
+
+//
+// The account mail: the thread behind each pipeline stage.
+//
+// Deliberately small — the point is that a stage has a conversation attached, not that the mailbox
+// is full. Threading is by subject: a reply reuses its root's subject, so the conversation list
+// groups them without an id scheme.
+//
+
+const OWNER: Actor.Actor = { role: 'user', name: 'Priya Raman', email: 'priya@northwind-sales.example' };
+
+type EmailSeed = {
+  readonly from: ContactKey | 'owner';
+  readonly subject: string;
+  readonly body: string;
+  /** Days before the reference date. */
+  readonly daysAgo: number;
+  readonly tags?: ReadonlyArray<SystemTags.SystemTagId>;
+};
+
+const EMAIL_SEEDS: ReadonlyArray<EmailSeed> = [
+  {
+    from: 'ruth',
+    subject: 'Question from the newsletter',
+    body: 'We are twelve people and drowning in spreadsheets. Is there a plan that makes sense at our size?',
+    daysAgo: 12,
+  },
+  {
+    from: 'owner',
+    subject: 'Re: Question from the newsletter',
+    body: 'There is — the team plan starts at ten seats. Happy to walk you through it. Are you free Thursday?',
+    daysAgo: 11,
+  },
+  {
+    from: 'mo',
+    subject: 'Pilot week two',
+    body: 'Eight of us are in it daily now. The import took a morning and nobody has asked me to undo it, which is high praise here.',
+    daysAgo: 9,
+    tags: ['important'],
+  },
+  {
+    from: 'gil',
+    subject: 'Security review — outcome',
+    body: 'Review is closed with no findings. Procurement has the paperwork; expect two weeks of silence and then a PO.',
+    daysAgo: 6,
+    tags: ['important', 'starred'],
+  },
+  {
+    from: 'ines',
+    subject: 'Finance sign-off',
+    body: 'We are a yes at 40 seats. Finance wants the invoice dated next quarter — workable?',
+    daysAgo: 4,
+    tags: ['starred'],
+  },
+  {
+    from: 'owner',
+    subject: 'Re: Finance sign-off',
+    body: 'Workable. I will date it the first of the quarter and note the seat count on the order form.',
+    daysAgo: 4,
+  },
+  {
+    from: 'dara',
+    subject: 'Adding the research arm',
+    body: 'Renewal is signed. Separately: research wants in, roughly 60 more seats. Who do I talk to about pricing that?',
+    daysAgo: 2,
+    tags: ['important'],
+  },
+  {
+    from: 'wes',
+    subject: 'Depot rollout order',
+    body: 'Dispatch is live and quiet. We would like to do the depots north-to-south rather than all at once.',
+    daysAgo: 1,
+  },
+];
+
+const textBlock = (text: string): ContentBlock.Text => ({ _tag: 'text', text }) satisfies ContentBlock.Text;
+
+const senderOf = (seed: EmailSeed): Actor.Actor => {
+  if (seed.from === 'owner') {
+    return OWNER;
+  }
+  const { fullName, email } = contactSeed(seed.from);
+  return { role: 'user', name: fullName, email };
+};
+
+// Strip a reply prefix so a reply lands in its root's thread.
+const threadIdFor = (subject: string): string =>
+  `thread-${
+    subject
+      .replace(/^(\s*(re|fwd?):\s*)+/i, '')
+      .trim()
+      .normalize('NFKD')
+      .replace(/[^a-zA-Z0-9]+/g, '-')
+      .replace(/^-+|-+$/g, '')
+      .toLowerCase() || 'thread'
+  }`;
+
+export type InboxResult = { mailbox: Mailbox.Mailbox; messages: Message.Message[] };
+
+/**
+ * The shared sales inbox. Mail the owner sent is tagged `sent`; everything else is `inbox`, which is
+ * what the mailbox's folders resolve against. Feed messages are immutable, so tag membership lives
+ * in the mailbox's child `TagIndex`.
+ */
+export const Inbox: SampleSpace.Phase<InboxResult> = SampleSpace.phase('inbox', {
+  schemas: [Mailbox.Mailbox, Message.Message, TagIndex.TagIndex, Tag.Tag, Feed.Feed],
+  run: () =>
+    Effect.gen(function* () {
+      const mailbox = yield* Database.add(Mailbox.make({ name: 'Sales' }));
+      const index = mailbox.tags.target;
+      const feed = mailbox.feed.target;
+      if (!index || !feed) {
+        return yield* Effect.fail(new SampleSpace.SampleSpaceError({ context: { reason: 'mailbox-incomplete' } }));
+      }
+
+      const messages = EMAIL_SEEDS.map((seed) => {
+        const threadId = threadIdFor(seed.subject);
+        return Message.make({
+          created: daysAgo(seed.daysAgo),
+          sender: senderOf(seed),
+          blocks: [textBlock(seed.body)],
+          threadId,
+          properties: { subject: seed.subject, threadId },
+        });
+      });
+
+      yield* SampleSpace.tagBatch(
+        messages.flatMap((message, index) => {
+          const seed = EMAIL_SEEDS[index];
+          const keys = [...(seed.from === 'owner' ? ['sent'] : ['inbox']), ...(seed.tags ?? [])];
+          return keys.map((key) => ({ object: message, key }));
+        }),
+        { index, resolve: (db, key) => SystemTags.findOrCreateSystemTag(db, key as SystemTags.SystemTagId) },
+      );
+
+      Obj.update(mailbox, (mailbox) => {
+        mailbox.subscriptions = Mailbox.deriveSubscriptions(messages);
+      });
+
+      yield* SampleSpace.appendToFeed(feed, messages);
+      return { mailbox, messages };
+    }),
+});

package/src/samples/crm/pipeline.ts

@@ -0,0 +1,70 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import * as SampleSpace from '@dxos/app-toolkit/SampleSpace';
+import { Database, Filter, JsonSchema, Query, Ref, View } from '@dxos/echo';
+import { ViewModel } from '@dxos/schema';
+import { Organization, Pipeline } from '@dxos/types';
+
+import { type AccountMap } from './accounts.ts';
+
+//
+// The pipeline board.
+//
+// A `Pipeline` column is a `View` plus an explicit `order` of object ids, so each stage is a query
+// (`status = 'qualified'`) rather than a hand-maintained membership list — an account moves stage by
+// having its `status` changed, which is what the board's drag does at runtime.
+//
+
+const STAGES = [
+  { name: 'Prospect', status: 'prospect' },
+  { name: 'Qualified', status: 'qualified' },
+  { name: 'Commit', status: 'commit' },
+  { name: 'Closed won', status: 'active' },
+  { name: 'Closed lost', status: 'reject' },
+] as const;
+
+const FIELDS = ['name', 'status', 'website', 'description'];
+
+export type PipelineResult = { pipeline: Pipeline.Pipeline };
+
+/** The board, plus a Table over every account for the flat view of the same data. */
+export const PipelineBoard: SampleSpace.Phase<PipelineResult, AccountMap> = SampleSpace.phase('pipeline', {
+  schemas: [Pipeline.Pipeline, View.View],
+  run: (accounts: AccountMap) =>
+    Effect.gen(function* () {
+      const jsonSchema = JsonSchema.toJsonSchema(Organization.Organization);
+
+      const columns = yield* Effect.forEach(STAGES, (stage) =>
+        Effect.gen(function* () {
+          const view = yield* Database.add(
+            ViewModel.make({
+              query: Query.select(Filter.type(Organization.Organization, { status: stage.status })),
+              queryRaw: undefined,
+              jsonSchema,
+              fields: FIELDS,
+            }),
+          );
+          // The column's order is explicit so a board that has been rearranged keeps its order; the
+          // seeds are listed in the order the stage should read.
+          const order = Object.values(accounts)
+            .filter((account) => account.status === stage.status)
+            .map((account) => account.id);
+          return { name: stage.name, order, view: Ref.make(view) };
+        }),
+      );
+
+      const pipeline = yield* Database.add(
+        Pipeline.make({
+          name: 'Sales pipeline',
+          description: 'Every account, by stage. Moving a card changes the account status.',
+          columns,
+        }),
+      );
+
+      return { pipeline };
+    }),
+});

package/src/samples/crm/util.ts

@@ -0,0 +1,18 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as SampleSpace from '@dxos/app-toolkit/SampleSpace';
+
+/** Stable reference date so regenerations are reproducible. Override with NOW=2026-05-20 env. */
+export const REFERENCE = process.env.NOW ? new Date(process.env.NOW) : new Date('2026-05-20T15:00:00Z');
+
+/**
+ * Bound to the same reference the definition declares, so the pure content builders can date their
+ * objects without every one of them being an effect.
+ */
+export const clock = SampleSpace.makeClock(REFERENCE);
+
+export const daysAgo = clock.daysAgo;
+
+export const daysFromNow = clock.daysFromNow;

package/src/samples/incident/IncidentSpace.test.ts

@@ -0,0 +1,68 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import { buildArchive, histogram } from '@dxos/app-toolkit/testing';
+import * as EffectEx from '@dxos/effect/EffectEx';
+
+import * as IncidentSpace from './IncidentSpace.ts';
+
+/**
+ * Built on demand rather than committed, so this asserts the shape in place of a fixture: if a
+ * schema it seeds changes incompatibly, the build fails here.
+ */
+describe('Incident template', () => {
+  test('builds the project, its sources and its four steps', { timeout: 120_000 }, async ({ expect }) => {
+    const { json, objectCount } = await EffectEx.runPromise(buildArchive(IncidentSpace.make()));
+    const counts = histogram(json);
+    const countOf = (typename: string) =>
+      Object.entries(counts)
+        .filter(([type]) => type.includes(typename))
+        .reduce((total, [, count]) => total + count, 0);
+
+    expect(objectCount).toBeGreaterThan(0);
+    expect(countOf('type.project')).toBe(1);
+    expect(countOf('type.instructions')).toBe(1);
+    expect(countOf('type.taskSet')).toBe(1);
+    // The log and four notes. The retro, timeline and notice are the work, so they are absent.
+    expect(countOf('type.document')).toBe(5);
+    expect(countOf('type.task:')).toBe(4);
+  });
+
+  test('every step is todo and each depends on the one before it', { timeout: 120_000 }, async ({ expect }) => {
+    const { json } = await EffectEx.runPromise(buildArchive(IncidentSpace.make()));
+    const objects: Array<{ '@type'?: string; 'title'?: string; 'status'?: string; 'dependsOn'?: unknown }> =
+      JSON.parse(json).objects;
+    const tasks = objects.filter((object) => object['@type']?.includes('type.task:'));
+
+    expect(tasks.map((task) => task.title)).toEqual([
+      'Reconstruct the timeline',
+      'Write the retrospective',
+      'File the action items',
+      'Draft the customer notice',
+    ]);
+    expect(tasks.every((task) => task.status === 'todo')).toBe(true);
+    expect(tasks.filter((task) => Array.isArray(task.dependsOn) && task.dependsOn.length > 0)).toHaveLength(3);
+  });
+
+  test(
+    'the log contradicts the notes on the points the retro must get right',
+    { timeout: 120_000 },
+    async ({ expect }) => {
+      const { json } = await EffectEx.runPromise(buildArchive(IncidentSpace.make()));
+      const objects: Array<{ '@type'?: string; 'content'?: string }> = JSON.parse(json).objects;
+      const texts = objects
+        .filter((object) => object['@type']?.includes('type.text'))
+        .map((object) => object.content ?? '');
+      const all = texts.join('\n');
+
+      // The distractors are present in the notes, and the log rules each one out.
+      expect(all).toContain('Friday deploys');
+      expect(all).toContain('No deploys');
+      expect(all).toContain('ran out of disk');
+      expect(all).toContain('Database disk usage held');
+    },
+  );
+});

package/src/samples/incident/IncidentSpace.ts

@@ -0,0 +1,61 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+// @import-as-namespace
+
+import * as Effect from 'effect/Effect';
+
+import type * as AppCapabilities from '@dxos/app-toolkit/AppCapabilities';
+import * as SampleSpace from '@dxos/app-toolkit/SampleSpace';
+import { Ref } from '@dxos/echo';
+
+import { Docs } from './docs.ts';
+import { ProjectPhase } from './project.ts';
+import { Tasks } from './tasks.ts';
+import { REFERENCE } from './util.ts';
+
+const phases = {
+  docs: Docs,
+  tasks: Tasks,
+  project: ProjectPhase,
+};
+
+/**
+ * An outage retrospective to delegate: a status log, four people's notes, and the four tasks that turn
+ * them into a filed retro with owned action items and a customer notice.
+ *
+ * Engineering in setting, not in kind. The technical cause is a certificate that expired, and the log
+ * states it outright; nothing here needs code read or written. The work is in the notes — a page sent
+ * to someone who left the team, a renewal reminder on a departed colleague's calendar, a support lead
+ * guessing who to call — and in holding them against the log, which contradicts two of them. That is
+ * the evaluation: does the retro recommend what the evidence supports, or what the loudest note says.
+ */
+export const make = (): SampleSpace.Definition<typeof phases, void> =>
+  SampleSpace.make({
+    space: { name: 'Incident 0516 retrospective', icon: 'stethoscope', hue: 'rose' },
+    reference: REFERENCE,
+    phases,
+    build: (phases) =>
+      Effect.gen(function* () {
+        const docs = yield* phases.docs();
+        const tasks = yield* phases.tasks();
+        yield* phases.project({ docs, tasks });
+
+        // The root holds collections only; the project and its tasks surface through their own containers.
+        yield* SampleSpace.collection('Sources', [
+          Ref.make(docs.log),
+          Ref.make(docs.notes.jae),
+          Ref.make(docs.notes.priya),
+          Ref.make(docs.notes.dan),
+          Ref.make(docs.notes.sam),
+        ]);
+      }),
+  });
+
+export const makeTemplate = (): AppCapabilities.SpaceTemplate =>
+  SampleSpace.makeTemplate({
+    id: 'org.dxos.plugin-debug.template.incident',
+    description: "A status log, four people's notes, and the four tasks that turn them into a filed retro.",
+    definition: make(),
+  });