@dxos/plugin-kanban 0.8.4-main.fcfe5033a5 → 0.8.4-staging.60fe92afc8

package/src/operations/restore-card-field.ts

@@ -3,34 +3,29 @@
 import * as Effect from 'effect/Effect';
 
 import { Capabilities, Capability } from '@dxos/app-framework';
-import { JsonSchema, Obj } from '@dxos/echo';
-import { type EchoSchema } from '@dxos/echo/internal';
+import { Operation } from '@dxos/compute';
+import { Obj, Type } from '@dxos/echo';
 import { invariant } from '@dxos/invariant';
-import { Operation } from '@dxos/operation';
-import { ProjectionModel, createEchoChangeCallback, getTypenameFromQuery } from '@dxos/schema';
+import { ProjectionModel, createEchoChangeCallback, getTypeURIFromQuery } from '@dxos/schema';
 
-import { RestoreCardField } from './definitions';
+import { KanbanOperation } from '../types';
 
-const handler: Operation.WithHandler<typeof RestoreCardField> = RestoreCardField.pipe(
+const handler: Operation.WithHandler<typeof KanbanOperation.RestoreCardField> = KanbanOperation.RestoreCardField.pipe(
   Operation.withHandler(
     Effect.fnUntraced(function* ({ view, field, props, index }) {
       const registry = yield* Capability.get(Capabilities.AtomRegistry);
       const db = Obj.getDatabase(view);
       invariant(db, 'Database not found');
-      const schema = yield* Effect.promise(() =>
-        db.schemaRegistry
-          .query({
-            typename: getTypenameFromQuery(view.query.ast)!,
-            location: ['database', 'runtime'],
-          })
-          .first(),
-      );
+      const types = db.graph.registry.list().filter(Type.isType);
+      const type = types.find((t) => Type.getURI(t) === getTypeURIFromQuery(view.query.ast));
+      invariant(type, 'Schema not found');
 
+      invariant(Type.isType(type), 'expected stored Type.Type for card schema');
       const projection = new ProjectionModel({
         registry,
         view,
-        baseSchema: JsonSchema.toJsonSchema(schema),
-        change: createEchoChangeCallback(view, schema as EchoSchema),
+        baseSchema: type.jsonSchema,
+        change: createEchoChangeCallback(view, type),
       });
 
       projection.setFieldProjection({ field, props }, index);

package/src/operations/restore-card.ts

@@ -2,13 +2,13 @@
 
 import * as Effect from 'effect/Effect';
 
+import { Operation } from '@dxos/compute';
 import { Obj } from '@dxos/echo';
 import { invariant } from '@dxos/invariant';
-import { Operation } from '@dxos/operation';
 
-import { RestoreCard } from './definitions';
+import { KanbanOperation } from '../types';
 
-const handler: Operation.WithHandler<typeof RestoreCard> = RestoreCard.pipe(
+const handler: Operation.WithHandler<typeof KanbanOperation.RestoreCard> = KanbanOperation.RestoreCard.pipe(
   Operation.withHandler(({ card }) =>
     Effect.sync(() => {
       const db = Obj.getDatabase(card);

package/src/playwright/smoke.spec.ts

@@ -49,7 +49,7 @@ test.describe('Kanban MutableSchema', () => {
     expect(secondLabel).not.toBeNull();
 
     // Drag first item below the second item.
-    await column.item(0).dragTo(column.item(1).locator, { x: 0, y: 200 });
+    await column.item(0).dragTo(column.item(1).locator, { x: 0, y: 200 }, 'bottom');
 
     // Item count should stay the same.
     await expect(column.items()).toHaveCount(countBefore);
@@ -71,8 +71,8 @@ test.describe('Kanban MutableSchema', () => {
     const draggedLabel = await col1.item(0).title().textContent();
     expect(draggedLabel).not.toBeNull();
 
-    // Drop above first item. Kanban cards are taller; use larger negative y so we land in top half.
-    await col1.item(0).dragTo(col2.item(0).locator, { x: 0, y: -30 });
+    // Drop above first item.
+    await col1.item(0).dragTo(col2.item(0).locator, { x: 0, y: -30 }, 'top');
 
     await expect(col1.items()).toHaveCount(col1CountBefore - 1);
     await expect(col2.items()).toHaveCount(col2CountBefore + 1);

package/src/plugin.ts

@@ -0,0 +1,11 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { Plugin } from '@dxos/app-framework';
+
+import { meta } from './meta';
+
+export const KanbanPlugin = Plugin.lazy(meta, () => import('#plugin'));
+
+export { KanbanOperationHandlerSet } from './operations';

package/src/testing/KanbanCardTileSimple.tsx

@@ -50,7 +50,7 @@ export const KanbanCardTileSimple = forwardRef<HTMLDivElement, KanbanCardProps>(
         >
           <Focus.Item asChild>
             <Card.Root ref={forwardedRef} data-testid='board-item'>
-              <Card.Toolbar>
+              <Card.Header>
                 <Card.DragHandle ref={dragHandleRef} />
                 <Card.Title>{Obj.getLabel(data)}</Card.Title>
                 {/* TODO(wittjosiah): Reconcile with Card.Menu. */}
@@ -63,14 +63,14 @@ export const KanbanCardTileSimple = forwardRef<HTMLDivElement, KanbanCardProps>(
                   />
                 </Menu.Trigger>
                 <Menu.Content items={menuItems} />
-              </Card.Toolbar>
-              <Card.Content>
-                <Card.Section>
+              </Card.Header>
+              <Card.Body>
+                <Card.Row fullWidth>
                   <pre className='p-2 text-xs text-description whitespace-pre-wrap'>
                     {JSON.stringify(data, null, 2)}
                   </pre>
-                </Card.Section>
-              </Card.Content>
+                </Card.Row>
+              </Card.Body>
             </Card.Root>
           </Focus.Item>
         </Mosaic.Tile>

package/src/types/Kanban.ts

@@ -4,15 +4,23 @@
 
 import * as Schema from 'effect/Schema';
 
-import { Annotation, Obj, Ref, Type } from '@dxos/echo';
-import { View } from '@dxos/echo';
-import { FormInputAnnotation, LabelAnnotation } from '@dxos/echo/internal';
+// QueryAST is referenced indirectly through `Type.InstanceType<typeof ...Schema>`
+// (Ref.Ref(View.View) → View.View → QueryAST.Query) in the emitted .d.ts; the
+// namespace import keeps the inferred types portable.
+// eslint-disable-next-line unused-imports/no-unused-imports
+import { DXN, Annotation, Obj, QueryAST, Ref, Type, View } from '@dxos/echo';
+import { FormInputAnnotation, LabelAnnotation } from '@dxos/echo/Annotation';
 import { ViewAnnotation } from '@dxos/schema';
 
-/** Per-column entry (ids order, optional hidden). */
+/**
+ * Per-column entry: ordered card ids plus an optional `hidden` flag that
+ * removes the column from the rendered board (and from the model's column
+ * list). Today only the uncategorized column is exposed in settings, but
+ * the data structure supports per-column hiding generally.
+ */
 const ArrangementColumnEntry = Schema.Struct({
   ids: Schema.Array(Obj.ID),
-  hidden: Schema.optional(Schema.Boolean),
+  hidden: Schema.Boolean.pipe(Schema.optional),
 });
 
 /** Keyed by columnValue. */
@@ -29,43 +37,98 @@ export const Arrangement = Schema.Struct({
 
 export type Arrangement = Schema.Schema.Type<typeof Arrangement>;
 
-export const Kanban = Schema.Struct({
-  name: Schema.optional(Schema.String),
+//
+// Mirrors the canonical DXOS pattern (see `Trigger.Spec` in
+// `@dxos/functions/src/types/Trigger.ts` and `Sequence.Source` in
+// `@dxos/plugin-zen`): the `Type.makeObject` schema is a flat `Schema.Struct`,
+// and the discriminated union lives one level down as a single field whose
+// variants are tagged with a `kind` literal.
+//
 
+/** View-variant: items come from running the View's query (the original behaviour). */
+export const KanbanViewSpec = Schema.Struct({
+  kind: Schema.Literal('view').pipe(FormInputAnnotation.set(false)),
   view: Ref.Ref(View.View).pipe(FormInputAnnotation.set(false)),
+});
+export type KanbanViewSpec = Schema.Schema.Type<typeof KanbanViewSpec>;
+
+/** Items-variant: kanban owns its items as an explicit ref array (used by externally-synced kanbans). */
+export const KanbanItemsSpec = Schema.Struct({
+  kind: Schema.Literal('items').pipe(FormInputAnnotation.set(false)),
+  /** Property path on each item that drives column membership (e.g. `'listName'`). */
+  pivotField: Schema.String,
+  /** Items owned directly by the kanban. */
+  items: Schema.Array(Ref.Ref(Obj.Unknown)).pipe(FormInputAnnotation.set(false)),
+});
+export type KanbanItemsSpec = Schema.Schema.Type<typeof KanbanItemsSpec>;
+
+/** Discriminated union of source specs. Distinguished by `kind`. */
+export const KanbanSpec = Schema.Union(KanbanViewSpec, KanbanItemsSpec);
+export type KanbanSpec = Schema.Schema.Type<typeof KanbanSpec>;
 
-  /** Column display order and per-column card ids. */
+export const Kanban = Schema.Struct({
+  name: Schema.String.pipe(Schema.optional),
   arrangement: Arrangement,
+  /** How this kanban sources its items. Discriminated by `spec.kind`. */
+  spec: KanbanSpec,
 }).pipe(
-  Type.object({
-    typename: 'org.dxos.type.kanban',
-    version: '0.1.0',
-  }),
   LabelAnnotation.set(['name']),
-  ViewAnnotation.set(true),
-  Annotation.IconAnnotation.set({
-    icon: 'ph--kanban--regular',
-    hue: 'green',
-  }),
+  ViewAnnotation.set(['spec', 'view']),
+  Annotation.IconAnnotation.set({ icon: 'ph--kanban--regular', hue: 'green' }),
+  Type.makeObject(DXN.make('org.dxos.type.kanban', '0.2.0')),
 );
 
-/** Instance type; use Kanban.Kanban in type position so namespace has .Kanban as type and .KanbanSchema as schema. */
-export interface Kanban extends Schema.Schema.Type<typeof Kanban> {}
+/**
+ * Instance type; narrow on `kanban.spec.kind` (or use the guards below).
+ */
+export interface Kanban extends Type.InstanceType<typeof Kanban> {}
+
+/** Narrowed view-variant kanban. */
+export type KanbanView = Kanban & { spec: KanbanViewSpec };
+
+/** Narrowed items-variant kanban. */
+export type KanbanItems = Kanban & { spec: KanbanItemsSpec };
 
-type MakeProps = Omit<Partial<Obj.MakeProps<typeof Kanban>>, 'view'> & {
+export const isKanbanView = (kanban: Kanban): kanban is KanbanView => kanban.spec.kind === 'view';
+export const isKanbanItems = (kanban: Kanban): kanban is KanbanItems => kanban.spec.kind === 'items';
+
+type MakeViewProps = {
+  name?: string;
   view: View.View;
+  arrangement?: Arrangement;
 };
 
 /**
- * Make a kanban as a view of a data set.
+ * Make a view-variant kanban (items sourced via the View's query).
  */
-export const make = (props: MakeProps): Kanban => {
+export const make = (props: MakeViewProps): Kanban => {
   const { name, view, arrangement } = props;
   const order = arrangement?.order ?? [];
   const columns = arrangement?.columns ?? {};
   return Obj.make(Kanban, {
     name,
-    view: Ref.make(view),
     arrangement: { order, columns },
+    spec: { kind: 'view' as const, view: Ref.make(view) },
+  });
+};
+
+type MakeItemsProps = {
+  name?: string;
+  arrangement?: Arrangement;
+  pivotField: string;
+  items?: ReadonlyArray<Ref.Ref<Obj.Unknown>>;
+};
+
+/**
+ * Make an items-variant kanban (items list owned by the kanban itself, e.g. populated by a sync integration).
+ */
+export const makeItems = (props: MakeItemsProps): Kanban => {
+  const { name, arrangement, pivotField, items = [] } = props;
+  const order = arrangement?.order ?? [];
+  const columns = arrangement?.columns ?? {};
+  return Obj.make(Kanban, {
+    name,
+    arrangement: { order, columns },
+    spec: { kind: 'items' as const, pivotField, items },
   });
 };

package/src/{operations/definitions.ts → types/KanbanOperation.ts}

@@ -1,14 +1,18 @@
+//
 // Copyright 2025 DXOS.org
+//
+
+// @import-as-namespace
 
 import * as Schema from 'effect/Schema';
 
 import { Capability } from '@dxos/app-framework';
-import { View } from '@dxos/echo';
-import { Operation } from '@dxos/operation';
+import { Operation } from '@dxos/compute';
+import { Type, View, DXN } from '@dxos/echo';
 
 import { meta } from '#meta';
 
-const KANBAN_OPERATION = `${meta.id}.operation`;
+const makeKey = (name: string) => DXN.make(`${meta.id}.operation.${name}`);
 
 export const DeleteCardFieldOutput = Schema.Struct({
   field: View.FieldSchema.annotations({ description: 'The deleted field schema.' }),
@@ -19,10 +23,14 @@ export const DeleteCardFieldOutput = Schema.Struct({
 export type DeleteCardFieldOutput = Schema.Schema.Type<typeof DeleteCardFieldOutput>;
 
 export const DeleteCardField = Operation.make({
-  meta: { key: `${KANBAN_OPERATION}.delete-card-field`, name: 'Delete Card Field' },
+  meta: {
+    key: makeKey('deleteCardField'),
+    name: 'Delete Card Field',
+    icon: 'ph--minus-circle--regular',
+  },
   services: [Capability.Service],
   input: Schema.Struct({
-    view: View.View,
+    view: Type.getSchema(View.View),
     fieldId: Schema.String,
   }),
   output: DeleteCardFieldOutput,
@@ -35,7 +43,7 @@ export const DeleteCardOutput = Schema.Struct({
 export type DeleteCardOutput = Schema.Schema.Type<typeof DeleteCardOutput>;
 
 export const DeleteCard = Operation.make({
-  meta: { key: `${KANBAN_OPERATION}.delete-card`, name: 'Delete Card' },
+  meta: { key: makeKey('deleteCard'), name: 'Delete Card', icon: 'ph--trash--regular' },
   input: Schema.Struct({
     card: Schema.Any,
   }),
@@ -43,10 +51,14 @@ export const DeleteCard = Operation.make({
 });
 
 export const RestoreCardField = Operation.make({
-  meta: { key: `${KANBAN_OPERATION}.restore-card-field`, name: 'Restore Card Field' },
+  meta: {
+    key: makeKey('restoreCardField'),
+    name: 'Restore Card Field',
+    icon: 'ph--clock-counter-clockwise--regular',
+  },
   services: [Capability.Service],
   input: Schema.Struct({
-    view: View.View.annotations({ description: 'The view to restore the field to.' }),
+    view: Type.getSchema(View.View).annotations({ description: 'The view to restore the field to.' }),
     field: View.FieldSchema.annotations({ description: 'The field schema to restore.' }),
     props: Schema.Any.annotations({ description: 'The field properties to restore.' }),
     index: Schema.Number.annotations({ description: 'The index to restore the field at.' }),
@@ -55,7 +67,11 @@ export const RestoreCardField = Operation.make({
 });
 
 export const RestoreCard = Operation.make({
-  meta: { key: `${KANBAN_OPERATION}.restore-card`, name: 'Restore Card' },
+  meta: {
+    key: makeKey('restoreCard'),
+    name: 'Restore Card',
+    icon: 'ph--clock-counter-clockwise--regular',
+  },
   input: Schema.Struct({
     card: Schema.Any.annotations({ description: 'The card to restore.' }),
   }),

package/src/types/index.ts

@@ -3,6 +3,8 @@
 //
 
 export * from './constants';
-export * as Kanban from './Kanban';
 export * from './schema';
 export type * from './types';
+
+export * as Kanban from './Kanban';
+export * as KanbanOperation from './KanbanOperation';

package/src/types/schema.ts

@@ -4,7 +4,7 @@
 
 import * as Schema from 'effect/Schema';
 
-import { TypeInputOptionsAnnotation } from '@dxos/plugin-space/types';
+import { TypeInputOptionsAnnotation } from '@dxos/plugin-space';
 
 /**
  * Kanban data model.
@@ -18,10 +18,28 @@ import { TypeInputOptionsAnnotation } from '@dxos/plugin-space/types';
 // TODO(wittjosiah): Factor out?
 export const PivotColumnAnnotationId = Symbol.for('@dxos/plugin-kanban/annotation/PivotColumn');
 
-export const SettingsSchema = Schema.Struct({
+/**
+ * Settings common to every Kanban (view or items). Rendered as form fields
+ * by `KanbanSettings`.
+ */
+export const KanbanSettingsSchema = Schema.Struct({
+  hideUncategorized: Schema.Boolean.annotations({
+    title: 'Hide uncategorized column',
+    description: 'When enabled, items without a pivot value won’t be shown as a column.',
+  }).pipe(Schema.optional),
+});
+
+/**
+ * Settings for view-variant Kanbans only. Spreads {@link KanbanSettingsSchema}'s
+ * fields and adds a column-field picker that binds the View’s pivot field.
+ * Items-variant kanbans use a hardcoded `spec.pivotField` and don’t expose
+ * this control.
+ */
+export const KanbanViewSettingsSchema = Schema.Struct({
   columnFieldId: Schema.String.annotations({
     title: 'Column field',
   }),
+  ...KanbanSettingsSchema.fields,
 });
 
 export const CreateKanbanSchema = Schema.Struct({

package/src/types/types.ts

@@ -30,13 +30,13 @@ export type KanbanColumn<T extends BaseKanbanItem = BaseKanbanItem> = {
 export type ArrangedCards<T extends BaseKanbanItem = BaseKanbanItem> = KanbanColumn<T>[];
 
 /**
- * Callback type for wrapping mutations in Obj.change().
+ * Callback type for wrapping mutations in Obj.update().
  * Contains separate callbacks for kanban object and item mutations.
  */
 export type KanbanChangeCallback<T extends BaseKanbanItem> = {
   /** Callback to wrap kanban object mutations. */
   kanban: (mutate: (mutableKanban: Obj.Mutable<Kanban>) => void) => void;
 
-  /** Sets a field on an item, wrapping in Obj.change() if needed. */
+  /** Sets a field on an item, wrapping in Obj.update() if needed. */
   setItemField: (item: T, field: string, value: unknown) => void;
 };

package/src/util/arrangement.test.ts

@@ -5,9 +5,8 @@
 import * as Schema from 'effect/Schema';
 import { beforeEach, describe, test } from 'vitest';
 
-import { Filter, JsonSchema, Query, Type } from '@dxos/echo';
-import { type View } from '@dxos/echo';
-import { ObjectId } from '@dxos/keys';
+import { DXN, Filter, JsonSchema, Query, Type, type View } from '@dxos/echo';
+import { EntityId } from '@dxos/keys';
 import { ViewModel } from '@dxos/schema';
 
 import { Kanban, UNCATEGORIZED_VALUE } from '#types';
@@ -26,7 +25,7 @@ const selectOptions = [
 ];
 
 const MinimalSchema = Schema.Struct({ id: Schema.String }).pipe(
-  Type.object({ typename: 'test/Minimal', version: '0.1.0' }),
+  Type.makeObject(DXN.make('com.example.type.minimal', '0.1.0')),
 );
 
 describe('arrangement utils', () => {
@@ -80,9 +79,9 @@ describe('arrangement utils', () => {
     });
 
     test('returns per-column ids and preserves hidden from kanban arrangement', ({ expect }) => {
-      const id1 = ObjectId.random();
-      const id2 = ObjectId.random();
-      const id3 = ObjectId.random();
+      const id1 = EntityId.random();
+      const id2 = EntityId.random();
+      const id3 = EntityId.random();
       const kanban = Kanban.make({
         view,
         arrangement: {
@@ -99,14 +98,24 @@ describe('arrangement utils', () => {
       expect(byColumn.b.hidden).toBeUndefined();
     });
 
+    test('treats non-array ids as empty (Automerge / corrupt layout)', ({ expect }) => {
+      const arrangement = {
+        order: [],
+        columns: { a: { ids: {} as unknown as string[] }, b: { ids: ['ok'] } },
+      };
+      const byColumn = getOrderByColumnFromArrangement(arrangement);
+      expect(byColumn.a.ids).toEqual([]);
+      expect(byColumn.b.ids).toEqual(['ok']);
+    });
+
     test('returns mutable copies', ({ expect }) => {
-      const idX = ObjectId.random();
+      const idX = EntityId.random();
       const kanban = Kanban.make({
         view,
         arrangement: { order: [], columns: { a: { ids: [idX] } } },
       });
       const byColumn = getOrderByColumnFromArrangement(kanban.arrangement);
-      byColumn.a.ids.push(ObjectId.random());
+      byColumn.a.ids.push(EntityId.random());
       expect(getOrderByColumnFromArrangement(kanban.arrangement).a.ids).toEqual([idX]);
     });
 
@@ -142,10 +151,10 @@ describe('arrangement utils', () => {
 
   describe('computeItemArrangement', () => {
     test('distributes items by pivotPath and preserves saved order within column', ({ expect }) => {
-      const idUc1 = ObjectId.random();
-      const idA1 = ObjectId.random();
-      const idA2 = ObjectId.random();
-      const idA3 = ObjectId.random();
+      const idUc1 = EntityId.random();
+      const idA1 = EntityId.random();
+      const idA2 = EntityId.random();
+      const idA3 = EntityId.random();
       const kanban = Kanban.make({
         view,
         arrangement: {

package/src/util/arrangement.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type SelectOption } from '@dxos/echo/internal';
+import { type SelectOption } from '@dxos/echo/Format';
 
 import {
   type ArrangedCards,
@@ -20,7 +20,7 @@ import {
  */
 export const getOrderFromArrangement = (arrangement?: Kanban.Arrangement): string[] => {
   const order = arrangement?.order;
-  if (order != null && order.length > 0) {
+  if (order != null && Array.isArray(order) && order.length > 0) {
     return [...order];
   }
 
@@ -41,10 +41,11 @@ export const getOrderByColumnFromArrangement = (
   const columns = arrangement?.columns;
   if (columns != null && Object.keys(columns).length > 0) {
     return Object.fromEntries(
-      Object.entries(columns).map(([key, entry]) => [
-        key,
-        { ids: [...(entry.ids ?? [])], ...(entry.hidden !== undefined && { hidden: entry.hidden }) },
-      ]),
+      Object.entries(columns).map(([key, entry]) => {
+        const rawIds = entry.ids;
+        const ids = Array.isArray(rawIds) ? [...rawIds] : [];
+        return [key, { ids, ...(entry.hidden !== undefined && { hidden: entry.hidden }) }];
+      }),
     );
   }
 
@@ -54,11 +55,15 @@ export const getOrderByColumnFromArrangement = (
 /**
  * Builds the ordered list of columns (value + ids) for the board model.
  *
- * Column order: uncategorized first, then effectiveOrder, then any selectOption ids not yet in order.
- * Each entry gets the ids from effectiveByColumn for that column (or empty).
+ * Column order: uncategorized first, then effectiveOrder, then any
+ * selectOption ids not yet in order. Each entry gets the ids from
+ * effectiveByColumn for that column (or empty). Columns whose entry has
+ * `hidden: true` are dropped from the result — currently only the
+ * "Uncategorized" column is toggleable from settings, but the filter is
+ * generic so any column can be hidden via the same flag.
  *
  * @param effectiveOrder - Column order from arrangement (or previous merge).
- * @param effectiveByColumn - Per-column card id order from arrangement.
+ * @param effectiveByColumn - Per-column card id order + hidden flag from arrangement.
  * @param selectOptions - Defines valid column ids; any missing from order are appended.
  * @returns ColumnStructure array in display order.
  */
@@ -78,10 +83,12 @@ export const computeColumnStructure = (
     }
   }
 
-  return order.map((columnValue) => ({
-    columnValue,
-    ids: effectiveByColumn[columnValue]?.ids ?? [],
-  }));
+  return order
+    .filter((columnValue) => effectiveByColumn[columnValue]?.hidden !== true)
+    .map((columnValue) => ({
+      columnValue,
+      ids: effectiveByColumn[columnValue]?.ids ?? [],
+    }));
 };
 
 /**
@@ -152,13 +159,16 @@ export const computeItemArrangement = <T extends BaseKanbanItem = BaseKanbanItem
   const validColumnValues = new Set(selectOptions.map((opt) => opt.id));
   const byColumn = getOrderByColumnFromArrangement(object?.arrangement);
 
-  // Column order: uncategorized first, then each select option (skip uncategorized if duplicated).
+  // Column order: uncategorized first, then each select option (skip
+  // uncategorized if duplicated). Columns whose arrangement entry has
+  // `hidden: true` are dropped — same generic hide-by-column flag used
+  // by `computeColumnStructure`.
   const columnEntries = [
     { columnValue: UNCATEGORIZED_VALUE, ids: byColumn[UNCATEGORIZED_VALUE]?.ids ?? [] },
     ...selectOptions
       .filter((opt) => opt.id !== UNCATEGORIZED_VALUE)
       .map((opt) => ({ columnValue: opt.id, ids: byColumn[opt.id]?.ids ?? [] })),
-  ];
+  ].filter((entry) => byColumn[entry.columnValue]?.hidden !== true);
 
   return columnEntries.map(({ columnValue, ids }) => ({
     columnValue,

package/src/vite-env.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="vite/client" />
+
+//
+// Copyright 2026 DXOS.org
+//
+
+declare module '*.mdl?raw' {
+  const content: string;
+  export default content;
+}

package/dist/lib/browser/blueprints/index.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../src/blueprints/kanban-blueprint.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { type AppCapabilities } from '@dxos/app-toolkit';\nimport { Blueprint, Template } from '@dxos/blueprints';\nimport { trim } from '@dxos/util';\n\nconst BLUEPRINT_KEY = 'org.dxos.blueprint.kanban';\n\nconst make = () =>\n  Blueprint.make({\n    key: BLUEPRINT_KEY,\n    name: 'Kanban',\n    tools: Blueprint.toolDefinitions({ tools: [] }),\n    instructions: Template.make({\n      source: trim`\n        You can create and update kanban boards to show data in sorted columns defined by schema.\n      `,\n    }),\n  });\n\nconst blueprint: AppCapabilities.BlueprintDefinition = {\n  key: BLUEPRINT_KEY,\n  make,\n};\n\nexport default blueprint;\n"],
-  "mappings": ";;;AAKA,SAASA,WAAWC,gBAAgB;AACpC,SAASC,YAAY;AAErB,IAAMC,gBAAgB;AAEtB,IAAMC,OAAO,MACXC,UAAUD,KAAK;EACbE,KAAKH;EACLI,MAAM;EACNC,OAAOH,UAAUI,gBAAgB;IAAED,OAAO,CAAA;EAAG,CAAA;EAC7CE,cAAcC,SAASP,KAAK;IAC1BQ,QAAQC;;;EAGV,CAAA;AACF,CAAA;AAEF,IAAMC,YAAiD;EACrDR,KAAKH;EACLC;AACF;AAEA,IAAA,2BAAeU;",
-  "names": ["Blueprint", "Template", "trim", "BLUEPRINT_KEY", "make", "Blueprint", "key", "name", "tools", "toolDefinitions", "instructions", "Template", "source", "trim", "blueprint"]
-}