@divlet/web 0.0.1 → 0.0.3

package/dist/lib/project.js

@@ -47,27 +47,29 @@ const clearRecovery = () => { failure = ''; recovery.replaceChildren(); };
 let input;
 let status;
 let primary;
+let primaryLabel;
+const actionLabels = { open: 'Open', save: 'Save here', project: 'Open project', collection: 'Open collection', create: 'Create project here', working: 'Working…' };
 
 export const isOpen = () => !scrim.hidden;
 export const canShowCopy = () => !!store.state?.project?.capabilities?.saveAs;
 
 function label() {
   const info = picker?.state.info;
-  if (!info) return { text: mode === 'open' ? 'Open' : 'Save here', ok: false, note: '' };
+  if (!info) return { text: mode === 'open' ? actionLabels.open : actionLabels.save, ok: false, note: '' };
   if (mode === 'open') {
-    if (info.kind === 'project') return { text: 'Open project', ok: true, note: 'A project is here.' };
-    if (info.kind === 'collection') return { text: 'Open collection', ok: true, note: `${info.projects} project${info.projects === 1 ? '' : 's'} here — pick one on the next page.` };
-    if (info.kind === 'new') return { text: 'Create project here', ok: true, note: 'No project in this folder yet.' };
-    return { text: 'Open project', ok: false, note: 'This folder does not exist.' };
+    if (info.kind === 'project') return { text: actionLabels.project, ok: true, note: 'A project is here.' };
+    if (info.kind === 'collection') return { text: actionLabels.collection, ok: true, note: `${info.projects} project${info.projects === 1 ? '' : 's'} here — pick one on the next page.` };
+    if (info.kind === 'new') return { text: actionLabels.create, ok: true, note: 'No project in this folder yet.' };
+    return { text: actionLabels.project, ok: false, note: 'This folder does not exist.' };
   }
-  if (info.kind === 'project' || info.kind === 'collection') return { text: 'Save here', ok: false, note: 'This folder already holds projects. Choose a new or empty folder.' };
-  if (info.kind === 'missing') return { text: 'Save here', ok: true, note: `Will create ${info.missing}.` };
-  return { text: 'Save here', ok: true, note: 'The folder must be empty.' };
+  if (info.kind === 'project' || info.kind === 'collection') return { text: actionLabels.save, ok: false, note: 'This folder already holds projects. Choose a new or empty folder.' };
+  if (info.kind === 'missing') return { text: actionLabels.save, ok: true, note: `Will create ${info.missing}.` };
+  return { text: actionLabels.save, ok: true, note: 'The folder must be empty.' };
 }
 
 function paintControls() {
   const state = label();
-  primary.textContent = busy ? 'Working…' : state.text;
+  primaryLabel.textContent = busy ? actionLabels.working : state.text;
   // Keep keyboard focus inside the modal when pending work disables a focused control.
   const focused = document.activeElement;
   if (focused === primary && (busy || !state.ok)) input.focus({ preventScroll: true });
@@ -127,6 +129,14 @@ function render() {
   status = el('span', 'caption project-status');
   status.setAttribute('role', 'status');
   primary = el('button', 'cta project-go');
+  primaryLabel = el('span', 'project-go-label');
+  primary.append(primaryLabel);
+  // All state labels share one grid cell, reserving real font-dependent width without another accessible control.
+  for (const text of Object.values(actionLabels)) {
+    const sizer = el('span', 'project-go-sizer', text);
+    sizer.setAttribute('aria-hidden', 'true');
+    primary.append(sizer);
+  }
   primary.type = 'button';
   primary.addEventListener('click', submit);
   const foot = el('div', 'dialog-foot');

package/dist/lib/store.js

@@ -1,5 +1,5 @@
 import { clamp } from './util.js';
-import { post, readSession, shareSelection } from './host.js';
+import { readSession, shareSelection, writer } from './host.js';
 export { base, apiUrl, request, post } from './host.js';
 
 const listeners = new Map();
@@ -20,6 +20,9 @@ export const store = {
   leaving: new Set(),
 };
 
+/** A capability is unavailable only when the host says `false`; native hosts predate the newer flags and omit them. */
+export const capable = name => store.state?.project?.capabilities?.[name] !== false;
+
 export const documents = () => (store.state?.documents || []).filter(doc => !store.leaving.has(doc.id));
 export const descriptor = id => documents().find(doc => doc.id === id);
 
@@ -117,10 +120,10 @@ function enqueue(documentId, task) {
   return result;
 }
 
-async function send(route, documentId, build, { version = Math.max(known.get(documentId) || 0, descriptor(documentId)?.version || 0), retry = true } = {}) {
+async function send(write, documentId, build, { version = Math.max(known.get(documentId) || 0, descriptor(documentId)?.version || 0), retry = true } = {}) {
   for (let attempt = 0; ; attempt++) {
     try {
-      const result = await post(route, build(version));
+      const result = await write(build(version));
       known.set(documentId, result.version);
       return result;
     } catch (error) {
@@ -136,32 +139,32 @@ export function commit(documentId, patch, { label, group, expectedVersion, expec
   const guard = expectedVersion === undefined ? {} : { version: expectedVersion, retry: false };
   const format = store.state?.project?.format;
   return enqueue(documentId, async () => {
-    if (typeof patch !== 'function') return send('api/patch', documentId, version => ({ documentId, expectedVersion: version, expectedRender, patch, label, group }), guard);
+    if (typeof patch !== 'function') return send(writer.patch, documentId, version => ({ documentId, expectedVersion: version, expectedRender, patch, label, group }), guard);
     if (store.state?.project?.format !== format) throw Object.assign(new Error('The source format changed. Read it again before retrying.'), { code: 'REVISION_CONFLICT' });
     const model = await freshModel(documentId);
     if (store.state?.project?.format !== format || model !== cachedModel(documentId) || model.version < (known.get(documentId) || 0)) throw Object.assign(new Error('The frame model is not current. Read it again before retrying.'), { code: 'REVISION_CONFLICT' });
     const derived = await patch(model);
     if (store.state?.project?.format !== format || model !== cachedModel(documentId)) throw Object.assign(new Error('The frame changed while preparing this edit. Read it again before retrying.'), { code: 'REVISION_CONFLICT' });
     if (!derived) return null;
-    return send('api/patch', documentId, version => ({ documentId, expectedVersion: version, expectedRender, patch: derived, label, group }), { version: expectedVersion ?? model.version, retry: false });
+    return send(writer.patch, documentId, version => ({ documentId, expectedVersion: version, expectedRender, patch: derived, label, group }), { version: expectedVersion ?? model.version, retry: false });
   }).catch(error => { toast(error.message); throw error; });
 }
 export function edit(documentId, op, { label, group, expectedRender } = {}) {
   const format = store.state?.project?.format;
   return enqueue(documentId, async () => {
-    if (typeof op !== 'function') return send('api/edit', documentId, expectedVersion => ({ documentId, expectedVersion, expectedRender, op, label, group }));
+    if (typeof op !== 'function') return send(writer.edit, documentId, expectedVersion => ({ documentId, expectedVersion, expectedRender, op, label, group }));
     // Derive relative legacy intent after local commits; native operations keep their shown-view guards.
     if (store.state?.project?.format !== format) throw Object.assign(new Error('The source format changed. Read it again before retrying.'), { code: 'REVISION_CONFLICT' });
     const model = await freshModel(documentId);
     if (store.state?.project?.format !== format || model !== cachedModel(documentId) || model.version < (known.get(documentId) || 0)) throw Object.assign(new Error('The frame model is not current. Read it again before retrying.'), { code: 'REVISION_CONFLICT' });
     const derived = op(model);
     if (!derived) return null;
-    return send('api/edit', documentId, expectedVersion => ({ documentId, expectedVersion, expectedRender, op: derived, label, group }), { version: model.version, retry: false });
+    return send(writer.edit, documentId, expectedVersion => ({ documentId, expectedVersion, expectedRender, op: derived, label, group }), { version: model.version, retry: false });
   }).catch(error => { toast(error.message); throw error; });
 }
 
-export const undo = () => post('api/undo', {}).catch(error => { toast(error.message); return null; });
-export const redo = () => post('api/redo', {}).catch(error => { toast(error.message); return null; });
+export const undo = () => writer.undo({}).catch(error => { toast(error.message); return null; });
+export const redo = () => writer.redo({}).catch(error => { toast(error.message); return null; });
 
 /* ---- selection ------------------------------------------------------------ */
 let selectionSequence = 0;

package/dist/lib/webmcp.d.ts

@@ -0,0 +1,34 @@
+import type { ToolRegistry } from './mcp-tools.ts';
+interface WebMcpToolInit {
+    name: string;
+    title?: string;
+    description: string;
+    inputSchema?: object;
+    annotations?: {
+        readOnlyHint?: boolean;
+        consequentialHint?: boolean;
+    };
+    execute(input: object, options: {
+        signal: AbortSignal;
+    }): Promise<unknown>;
+}
+/** The part of the draft's `ModelContext` this adapter uses. */
+export interface WebMcpModelContext {
+    registerTool(tool: WebMcpToolInit, options?: {
+        signal?: AbortSignal;
+    }): Promise<unknown> | unknown;
+}
+/**
+ * Register every tool of `registry` with WebMCP. Resolves to the names that registered (an empty list when the browser has no
+ * `document.modelContext`, for example outside a secure context) and a function that unregisters them. Failures of individual
+ * registrations are reported, never thrown: WebMCP is a compatibility surface, not a requirement.
+ */
+export declare function registerWebMcpTools(registry: ToolRegistry, context?: unknown): Promise<{
+    registered: string[];
+    failed: Array<{
+        name: string;
+        message: string;
+    }>;
+    unregister: () => void;
+}>;
+export {};

package/dist/lib/webmcp.js

@@ -0,0 +1,37 @@
+const isModelContext = (value) => !!value && typeof value.registerTool === 'function';
+/**
+ * Register every tool of `registry` with WebMCP. Resolves to the names that registered (an empty list when the browser has no
+ * `document.modelContext`, for example outside a secure context) and a function that unregisters them. Failures of individual
+ * registrations are reported, never thrown: WebMCP is a compatibility surface, not a requirement.
+ */
+export async function registerWebMcpTools(registry, context = globalThis.document?.modelContext) {
+    const controller = new AbortController();
+    const unregister = () => controller.abort();
+    if (!isModelContext(context))
+        return { registered: [], failed: [], unregister };
+    const registered = [], failed = [];
+    for (const descriptor of registry.descriptors) {
+        const readOnly = descriptor.annotations?.readOnlyHint === true;
+        const init = {
+            name: descriptor.name,
+            ...(descriptor.title ? { title: descriptor.title } : {}),
+            description: descriptor.description,
+            inputSchema: descriptor.inputSchema,
+            annotations: { readOnlyHint: readOnly, consequentialHint: !readOnly && descriptor.annotations?.destructiveHint !== false },
+            async execute(input, options) {
+                const outcome = await registry.run(descriptor.name, input, { signal: options?.signal });
+                if (outcome.ok)
+                    return outcome.value;
+                throw Object.assign(new Error(`${outcome.error.code}: ${outcome.error.message}`), { code: outcome.error.code });
+            },
+        };
+        try {
+            await context.registerTool(init, { signal: controller.signal });
+            registered.push(descriptor.name);
+        }
+        catch (error) {
+            failed.push({ name: descriptor.name, message: String(error?.message || error) });
+        }
+    }
+    return { registered, failed, unregister };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@divlet/web",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "The divlet browser board, static client assets and transport-free host ports",
   "type": "module",
   "license": "MIT",
@@ -24,6 +24,10 @@
     "./host": {
       "divlet-source": "./lib/board-host.ts",
       "default": "./dist/lib/board-host.js"
+    },
+    "./mcp": {
+      "divlet-source": "./lib/mcp-provider.ts",
+      "default": "./dist/lib/mcp-provider.js"
     }
   },
   "files": [