@feasibleone/blong-gogo 1.35.0 → 1.36.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [1.36.0](https://github.com/feasibleone/blong/compare/blong-gogo-v1.35.0...blong-gogo-v1.36.0) (2026-09-24)
+
+
+### Features
+
+* add from property to leg ([4925e76](https://github.com/feasibleone/blong/commit/4925e76a7d69000e83804cd9a5fa1ea58ab26d81))
+* docs screenshots and diagrams ([65e37d9](https://github.com/feasibleone/blong/commit/65e37d93ef3e71d65b340541e14b50a25f14e3c8))
+* sequence diagram progress points ([dc5b153](https://github.com/feasibleone/blong/commit/dc5b15327f31698a26a75ec73bdf9a0956a43dd9))
+
+
+### Bug Fixes
+
+* build errors ([145a424](https://github.com/feasibleone/blong/commit/145a424ffc2dc4dfc14801f1002c7fa1e7a543ce))
+
 ## [1.35.0](https://github.com/feasibleone/blong/compare/blong-gogo-v1.34.0...blong-gogo-v1.35.0) (2026-09-21)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feasibleone/blong-gogo",
-  "version": "1.35.0",
+  "version": "1.36.0",
   "repository": {
     "url": "git+https://github.com/feasibleone/blong.git"
   },
@@ -91,7 +91,7 @@
     "tap": "^21.6.3",
     "typescript": "^6.0.3",
     "vite": "^8.2.1",
-    "@feasibleone/blong-dev": "1.5.0"
+    "@feasibleone/blong-dev": "1.6.0"
   },
   "scripts": {
     "browser-check": "node scripts/browser-compat-check.mjs",

package/src/AdapterBase.ts

@@ -15,7 +15,14 @@ import PQueue from 'p-queue';
 import ConfigRuntime from './ConfigRuntime.ts';
 import {isExpectedError, portLogCalls} from './lib.ts';
 import loop from './loop.ts';
-import {adoptInbound, inboundIdentities, isFlowId} from './semanticContext.ts';
+import {
+    adoptInbound,
+    attachProgress,
+    beginProgress,
+    inboundIdentities,
+    isFlowId,
+    takeProgress,
+} from './semanticContext.ts';
 
 const errorMap: IErrorMap = {
     'adapter.configValidation': 'Adapter config validation:\r\n{message}',
@@ -376,15 +383,36 @@ export class AdapterBase<T, C extends IContext> implements AdapterHandlerContext
             // leg that arrived: that is what turns the caller's declaration into a receipt
             // the ledger can match, and it happens only when a flow was traced at all, so an
             // untraced request still pays nothing.
-            const answered = (): unknown => {
+            const answered = async (): Promise<unknown> => {
                 const inbound = inboundIdentities($meta as IMeta);
-                if (isFlowId(inbound.flow) && inbound.leg !== undefined) {
+                const traced = isFlowId(inbound.flow) && inbound.leg !== undefined;
+                if (traced) {
                     // The receipt is the receiver's record for the leg it was handed. It carries
                     // no declared target - the caller named the ends - so the ledger can tell a
                     // receipt from a declaration by the leg alone, in one process or many.
-                    portLogCalls(this)?.received(inbound.leg);
+                    portLogCalls(this)?.received(inbound.leg as string);
+                    // And the collection starts *before* the handler runs, because the boxes it will
+                    // read are installed with `enterWith`: one created after the handler's first wait
+                    // never reaches the frame that answers for the call (T-136).
+                    beginProgress();
                 }
-                return run();
+                const result = await run();
+                // What the handler announced while it ran (`$meta.checkpoint`, `$meta.decide`) is
+                // staged in the scope around it and written on no record of its own: the records
+                // of a call are the framework's, written before the handler starts and after it
+                // returns. Reading the progress here — inside that scope, once the handler is
+                // done — is what lets the call answer with its own work: a point becomes a note
+                // beside this hop, and a branch becomes the alternative that was taken
+                // (PRD R26/R27). Nothing is written when a handler announced nothing, so an
+                // uninstrumented call still costs one scope read.
+                if (traced) {
+                    const progress = takeProgress();
+                    if (progress !== undefined) {
+                        attachProgress(progress);
+                        portLogCalls(this)?.answered(inbound.leg as string);
+                    }
+                }
+                return result;
             };
             // The callee adopts the identity its caller declared, so the records its
             // handler writes belong to the caller's execution and its own calls are

package/src/Gateway.ts

@@ -592,17 +592,17 @@ export default class Gateway extends Internal implements IGateway {
                                     // Declare the hop this route is making. The caller is
                                     // **`public`** - the surface that answered the request,
                                     // named apart from the namespace it calls. The gateway realm
-                                    // is a namespace called `gateway`, so a leg whose caller was
-                                    // also called `gateway` drew the public surface and that
-                                    // namespace as one participant, and a realm answering a call
-                                    // to its own namespace read as a self-call. A leg id names a
-                                    // unit, and the API surface is a unit of its own - not the
-                                    // process either: one process hosts a whole suite, so naming
-                                    // the process here would draw every flow of a monolith as the
-                                    // same participant.
-                                    // `methodName` is already the dotted wire name the leg
-                                    // grammar wants, so the leg names the method the request
-                                    // asked for. The callee's receipt then carries the same leg,
+                                    // is a namespace called `gateway`, so a caller that was also
+                                    // called `gateway` drew the public surface and that namespace
+                                    // as one participant, and a realm answering a call to its own
+                                    // namespace read as a self-call. The API surface is a unit of
+                                    // its own - not the process either: one process hosts a whole
+                                    // suite, so naming the process here would draw every flow of a
+                                    // monolith as the same participant.
+                                    // `methodName` is the wire name the request asked for, and it
+                                    // is the leg: the caller is declared beside it, so a diagram
+                                    // labels the arrow with the method and draws its source from
+                                    // the unit. The callee's receipt then carries the same leg,
                                     // which is what makes the drawing a call rather than a
                                     // participation.
                                     declareCall(

package/src/Registry.ts

@@ -25,6 +25,7 @@ import merge from 'ut-function.merge';
 
 import * as blongLib from '@feasibleone/blong-lib';
 import {renderAll} from '@feasibleone/blong-template';
+import {vocabulary} from '@feasibleone/semantic-log/attachable';
 import {createAttachCheckpoint} from './checkpoint.ts';
 import {methodId, methodParts} from './lib.ts';
 import type {IResolution} from './Resolution.ts';
@@ -369,13 +370,25 @@ export default class Registry extends Internal implements IRegistry {
         port: object | undefined,
     ): Promise<{local: object; literals: object[]}> {
         const attachCheckpoint = this.#attachCheckpoint;
+        const recording = (this.#config.checkpointMode ?? 'production') !== 'production';
         const lib = {
+            // The library's own surface first, so an injected handle can never be silently
+            // overwritten by a name it happens to share: `blongLib` exports `checkpoint`
+            // for the snapshot marker, and the spread used to sit *after* these members.
+            ...blongLib,
             error: this.#error.register.bind(this.#error),
-            assert: attachCheckpoint ? nodeAssert : undefined,
+            assert: recording ? nodeAssert : undefined,
+            // The progress-point pair (PRD R26). `checkpoint` reports a milestone from code that
+            // has no `$meta` — it is the emitter's own `point` reached through the attachable
+            // facade, and it is `undefined` in production for the same reason `$meta.checkpoint`
+            // is: a note nobody records must cost nothing. `decide` selects, so it is always
+            // there, and it is the same function in every mode — what the mode decides is whether
+            // a record carries the rationale, not whether the branch is taken.
+            checkpoint: recording ? vocabulary.point : undefined,
+            decide: vocabulary.decide,
             render: (what: object[] | object) =>
                 renderAll(Array.isArray(what) ? merge(...what) : what, this.#platform.context),
             timing: this.#platform.timing,
-            ...blongLib,
             // The runtime services a `library()` function needs, mirroring the
             // port API (`registry: this`, `platform: …`).
             //

package/src/SemanticLog.test.ts

@@ -52,6 +52,54 @@ t.test('a cache configured without a bound takes the default', async t => {
     t.equal(log.store.stats().size, 1, 'the default bound retains a record comfortably');
 });
 
+t.test('a record carries the branch and the points of the scope that wrote it', async t => {
+    // PRD R26/R27: the framework's logger must not have to know about progress points for them to
+    // reach a record — they ride the emitter's ambient scope, and what this pins is that the
+    // framework's own path (`semanticRecord.ts`, `LogBase`, the call channel that goes through the
+    // same logger) reads that scope rather than writing a record of its own.
+    const dir = await mkdtemp(join(tmpdir(), 'blong-semantic-log-'));
+    t.teardown(() => rm(dir, {recursive: true, force: true}));
+    const log = new SemanticLog({level: 'info', cache: {dir}});
+    await log.init();
+    const at = log.logger('info', {name: 'progress'});
+
+    const chosen = vocabulary.decide('route-selection', {corridor: 'EUR-USD'}, [
+        {name: 'hold', when: () => false, run: () => 'hold'},
+        {
+            name: 'hubB',
+            when: () => true,
+            run: () => {
+                vocabulary.point('corridor-resolved', {hub: 'B'});
+                at.info?.('routing to the far ecosystem');
+                return 'hubB';
+            },
+        },
+    ]);
+    t.equal(chosen, 'hubB', 'the branch ran');
+    await log.stop();
+
+    let record: {msg?: string; progress?: {regions?: unknown[]; points?: unknown[]}} | undefined;
+    for (const id of await cacheRecordIds(dir)) {
+        const candidate = await log.store.get(id);
+        if (candidate?.msg === 'routing to the far ecosystem') {
+            record = candidate;
+        }
+    }
+    t.ok(record, 'the record the branch wrote was retained');
+    t.same(
+        (record?.progress?.regions as Array<{discriminator: string; chosen: string}>).map(
+            region => [region.discriminator, region.chosen],
+        ),
+        [['route-selection', 'hubB']],
+        'it was emitted inside the branch, which is what a diagram draws as an alt block',
+    );
+    t.same(
+        (record?.progress?.points as Array<{name: string}>).map(point => point.name),
+        ['corridor-resolved'],
+        'and the point announced in that scope rides the same record',
+    );
+});
+
 t.test('the home-relative cache path the framework uses is expanded', t => {
     // The framework's own configuration names the shared log cache as
     // `~/.blong/log-cache`, and the pino transport expands that itself — so a
@@ -329,13 +377,14 @@ t.test('a record made inside a flow names the flow, the call and the position',
     );
     const [id] = await cacheRecordIds(dir);
     const record = (await log.store.get(id ?? '')) as unknown as {
-        flow?: {id?: string; leg?: string; legTo?: string; legSeq?: string};
+        flow?: {id?: string; leg?: string; legFrom?: string; legTo?: string; legSeq?: string};
     };
     t.equal(
         record.flow?.leg,
-        'access.db.party.subject.find',
-        'the record names the call it was made in',
+        'party.subject.find',
+        'the record names the call it was made in, by the method it was made by',
     );
+    t.equal(record.flow?.legFrom, 'access.db', 'and the unit that made it, beside the method');
     t.equal(record.flow?.legTo, 'party', 'and the participant the caller aimed at');
     t.match(String(record.flow?.legSeq), /^[0-9]+$/, 'and its position in the execution');
     t.equal(isFlowId(record.flow?.id), true, 'and the execution it is part of');
@@ -382,8 +431,8 @@ t.test('the records of a flow reach the cluster service and come back as a diagr
     t.equal(diagram?.statusCode, 200, 'the execution can be drawn from the records alone');
     t.match(
         diagram?.body ?? '',
-        /access\.db\.party\.subject\.find/,
-        'and the drawing names the call the caller declared',
+        /party\.subject\.find/,
+        'and the drawing names the call the caller declared, by its method',
     );
 });
 

package/src/adapterProgress.test.ts

@@ -0,0 +1,190 @@
+/**
+ * What a handler announced, on the answer of the call it handled (PRD R26/R27).
+ *
+ * The gap this closes, measured before it was closed: a realm handler announced five points and
+ * one branch through `$meta.checkpoint` / `$meta.decide`, and **no record carried any of them** —
+ * 0 of 5056 retained records. The handles work; the records do not. A call's records are written
+ * by the framework *around* the handler (the receipt before it runs, the answer from the caller's
+ * end), so the ambient scope the handler staged into never emits one, and everything it announced
+ * is dropped with that scope.
+ *
+ * What is pinned here is the receiver's half: the adapter reads what its handler announced once
+ * the handler returns and reports it on the leg it answered, which is a record the ledger already
+ * matches. Two properties matter and both are asserted below — the progress is *re-announced* (so
+ * the logger's own facet machinery puts it on the record, rather than a second way of writing
+ * records being invented), and nothing is written when the handler announced nothing.
+ */
+import type {IMeta} from '@feasibleone/blong/types';
+import {attachSemanticVocabulary} from '@feasibleone/semantic-log/attachable';
+import * as vocabulary from '@feasibleone/semantic-log/emitter';
+import t from 'tap';
+import {AdapterBase} from './AdapterBase.ts';
+import {createAttachCheckpoint} from './checkpoint.ts';
+
+// The framework reaches the vocabulary by attachment (the emitter's scope is Node-only, and the
+// browser bootstrap loads this module too), so a tap process attaches it exactly as `loadServer.ts`
+// does. Without it the handles degrade and there is nothing to report.
+attachSemanticVocabulary(vocabulary);
+
+/** A canonical flow ULID. */
+const FLOW = '01ARZ3NDEKTSV4RRFFQ69G5FAV';
+
+/** The leg the caller declared for the call this adapter answers. */
+const LEG = 'gateway.bundle.merge';
+
+/**
+ * The `$meta` a receiver is handed, built the way the wire builds it: the identities travel in
+ * the header bag, and the leg is in it because the caller declared one.
+ */
+function inboundMeta(): IMeta {
+    const forward = vocabulary.withFlow({id: FLOW, kind: 'transfer.single'}, () =>
+        vocabulary.bindLeg({id: LEG, from: 'public', to: 'gateway'}, () =>
+            vocabulary.identityHeaders(),
+        ),
+    );
+    return {mtid: 'event', method: 'exec', forward};
+}
+
+/** What the fake call channel saw, with the progress staged at the moment it was asked. */
+interface ISeen {
+    phase: string;
+    leg: string;
+    points?: unknown;
+    regions?: unknown;
+}
+
+/**
+ * The adapter under test: the real `handle`, on an instance built without a constructor.
+ *
+ * `handle` reads exactly three things — the imported handler table, the checkpoint attach hook and
+ * the call channel — so those are the three that are set. The alternative, going through
+ * `adapterFactory`, would drag in the registry, the schema and the config runtime to test a
+ * twenty-line method.
+ */
+function receiver(handler: (params: unknown[]) => unknown, seen: ISeen[]) {
+    const adapter = Object.create(AdapterBase.prototype) as AdapterBase<unknown, never>;
+    adapter.imported = {exec: handler as never};
+    adapter._attachCheckpoint = createAttachCheckpoint('debug');
+    // The method-id hook is the constructor's, and it is asked before the handler is found. Identity
+    // is the honest stub for a test: the real one names a method the way its realm does.
+    adapter._methodId = (name: string) => name;
+    (adapter as unknown as {log: unknown}).log = {
+        calls: {
+            enabled: () => true,
+            start: () => undefined,
+            end: () => undefined,
+            error: () => undefined,
+            received: (leg: string) => void seen.push({phase: 'received', leg}),
+            // Read at the moment the answer is written, which is the whole point: what the
+            // framework staged onto the scope is what the record will carry.
+            answered: (leg: string) => {
+                const points = vocabulary.takePoints();
+                const regions = vocabulary.currentRegions();
+                seen.push({
+                    phase: 'answered',
+                    leg,
+                    ...(points ? {points} : {}),
+                    ...(regions ? {regions} : {}),
+                });
+            },
+        },
+    };
+    return adapter;
+}
+
+t.test('the answer of a call carries what its handler announced', async t => {
+    const seen: ISeen[] = [];
+    const meta = inboundMeta();
+    const adapter = receiver(() => {
+        meta.checkpoint?.('merge-started', {bundles: 1});
+        return meta.decide?.('role-bit', {declared: null}, [
+            {name: 'allocated', when: () => true, run: () => 'allocated'},
+            {name: 'declared', when: () => false, run: () => 'declared'},
+        ]);
+    }, seen);
+
+    const result = await adapter.handle({}, meta);
+    t.equal(result, 'allocated', 'the handler answered');
+
+    t.same(
+        seen.map(event => event.phase),
+        ['received', 'answered'],
+        'the receiver writes a receipt when the call arrives and an answer when its work is done',
+    );
+    t.equal(seen[1]?.leg, LEG, 'and the answer names the leg it was handed');
+    t.same(
+        seen[1]?.points,
+        [{name: 'merge-started', data: {bundles: 1}}],
+        'the point the handler announced is staged for the answer',
+    );
+    t.same(
+        (
+            seen[1]?.regions as Array<{
+                discriminator: string;
+                chosen: string;
+                candidates: string[];
+            }>
+        ).map(region => [region.discriminator, region.chosen, region.candidates]),
+        [['role-bit', 'allocated', ['allocated', 'declared']]],
+        'and so is the branch it took, so the block can be drawn around this hop',
+    );
+});
+
+t.test('a handler that waits before it announces is still answered for', async t => {
+    // The regression this pins: the collection's boxes are installed with `enterWith`, which
+    // reaches the current context and what follows it — never a frame that is already suspended.
+    // A handler that awaits before it announces anything resumes in a context whose boxes were
+    // created after the receiver's continuation was bound, so without installing them first the
+    // branch mark (and every point staged after the wait) reached no record: measured live, the
+    // points survived and the branch did not.
+    const seen: ISeen[] = [];
+    const meta = inboundMeta();
+    const adapter = receiver(async () => {
+        await new Promise(resolve => setTimeout(resolve, 1));
+        meta.checkpoint?.('after-the-wait');
+        return meta.decide?.('role-bit', {declared: null}, [
+            {name: 'allocated', when: () => true, run: () => 'allocated'},
+            {name: 'declared', when: () => false, run: () => 'declared'},
+        ]);
+    }, seen);
+
+    await adapter.handle({}, meta);
+    t.same(
+        seen.map(event => event.phase),
+        ['received', 'answered'],
+        'the answer is still written after a wait',
+    );
+    t.same(seen[1]?.points, [{name: 'after-the-wait'}], 'with the point announced after it');
+    t.same(
+        (
+            seen[1]?.regions as Array<{
+                discriminator: string;
+                chosen: string;
+                candidates: string[];
+            }>
+        ).map(region => [region.discriminator, region.chosen, region.candidates]),
+        [['role-bit', 'allocated', ['allocated', 'declared']]],
+        'and the branch it took, which is what the alt block is drawn from',
+    );
+});
+
+t.test('a handler that announced nothing writes no answer', async t => {
+    const seen: ISeen[] = [];
+    const meta = inboundMeta();
+    const adapter = receiver(() => ({success: true}), seen);
+    await adapter.handle({}, meta);
+    t.same(
+        seen.map(event => event.phase),
+        ['received'],
+        'an uninstrumented call still pays nothing beyond its receipt',
+    );
+});
+
+t.test('an untraced call records nothing at all', async t => {
+    const seen: ISeen[] = [];
+    const adapter = receiver(() => {
+        return {success: true};
+    }, seen);
+    await adapter.handle({}, {mtid: 'event', method: 'exec'});
+    t.same(seen, [], 'no flow on the call, so no records — the gate is asked first');
+});

package/src/checkpoint.test.ts

@@ -0,0 +1,176 @@
+/**
+ * The framework's two progress-point handles (PRD R11/R26).
+ *
+ * A checkpoint reports a moment; a decision selects a branch. That difference is the whole
+ * reason one is optional and the other is not, so it is pinned here: a checkpoint exists
+ * only where points are recorded, a decision exists in every mode, and both reach the log
+ * through the attachable vocabulary — degrading to nothing and to a plain selection where
+ * no emitter is attached, because a dispatch path must never reach the emitter's ambient
+ * scope (F-197).
+ */
+import type {IMeta} from '@feasibleone/blong/types';
+import {
+    attachSemanticVocabulary,
+    detachSemanticVocabulary,
+} from '@feasibleone/semantic-log/attachable';
+import * as semantic from '@feasibleone/semantic-log/emitter';
+import t from 'tap';
+import {createAttachCheckpoint} from './checkpoint.ts';
+
+const MODES = ['production', 'debug', 'test'] as const;
+
+t.test('a branch is taken and its rationale kept, in every mode', t => {
+    for (const mode of MODES) {
+        const meta: IMeta = {};
+        createAttachCheckpoint(mode)(meta);
+        const result = meta.decide?.('rate-within-limit', {rate: 2}, [
+            {name: 'decline', when: values => (values.rate as number) > 1, run: () => 'declined'},
+            {name: 'accept', when: () => true, run: () => 'accepted'},
+        ]);
+        t.equal(result, 'declined', `${mode}: the branch is taken`);
+        t.same(
+            meta.decisions,
+            [
+                {
+                    discriminator: 'rate-within-limit',
+                    candidates: ['decline', 'accept'],
+                    chosen: 'decline',
+                    values: {rate: 2},
+                },
+            ],
+            `${mode}: and the invocation keeps which one it was`,
+        );
+    }
+    t.end();
+});
+
+t.test('a checkpoint exists only where points are recorded', t => {
+    const production: IMeta = {};
+    createAttachCheckpoint('production')(production);
+    t.notOk(
+        production.checkpoint,
+        'absent in production, which is what makes the `?.` call cost nothing',
+    );
+    t.ok(production.decide, 'while the branch helper is there, because a branch cannot be skipped');
+
+    const debug: IMeta = {};
+    createAttachCheckpoint('debug')(debug);
+    debug.checkpoint?.('total-calculated', {total: 200});
+    t.equal(debug.checkpoints?.length, 1, 'recorded where points are');
+    t.equal(debug.checkpoints?.[0]?.name, 'total-calculated');
+    t.same(debug.checkpoints?.[0]?.data, {total: 200});
+    t.type(debug.checkpoints?.[0]?.timestamp, 'number', 'and stamped when it happened');
+    t.end();
+});
+
+t.test('a checkpoint is announced to the log, and announces nothing without one', t => {
+    detachSemanticVocabulary();
+    const detached: IMeta = {};
+    createAttachCheckpoint('test')(detached);
+    detached.checkpoint?.('no-log');
+    t.equal(
+        semantic.takePoints(),
+        undefined,
+        'nothing is announced where no emitter is attached: the degradation is the whole point',
+    );
+
+    attachSemanticVocabulary(semantic);
+    t.teardown(() => detachSemanticVocabulary());
+    const attached: IMeta = {};
+    createAttachCheckpoint('test')(attached);
+    attached.checkpoint?.('total-calculated', {total: 200});
+    t.same(
+        semantic.takePoints(),
+        [{name: 'total-calculated', data: {total: 200}}],
+        'PRD R26: the milestone reaches the log, so a diagram can draw it as a note',
+    );
+    t.equal(semantic.takePoints(), undefined, 'and is taken once, by the record that carries it');
+    t.end();
+});
+
+t.test('a decision is announced to the log too, and still selects without one', t => {
+    detachSemanticVocabulary();
+    const detached: IMeta = {};
+    createAttachCheckpoint('test')(detached);
+    t.equal(
+        detached.decide?.('d', {}, [{name: 'only', when: () => true, run: () => 7}]),
+        7,
+        'the branch is taken with nothing attached',
+    );
+    t.equal(semantic.takeDecision(), undefined, 'and no rationale is staged to record');
+
+    attachSemanticVocabulary(semantic);
+    t.teardown(() => detachSemanticVocabulary());
+    const attached: IMeta = {};
+    createAttachCheckpoint('test')(attached);
+    attached.decide?.('route-selection', {}, [
+        {name: 'hubB', when: () => true, run: () => 'hubB'},
+        {name: 'hold', when: () => true, run: () => undefined},
+    ]);
+    t.same(
+        semantic.takeDecision()?.candidates,
+        ['hubB', 'hold'],
+        'the rationale is staged for the next record, in evaluation order (PRD R11)',
+    );
+    t.end();
+});
+
+t.test('no branch matching is a recorded non-choice', t => {
+    const meta: IMeta = {};
+    createAttachCheckpoint('test')(meta);
+    t.equal(meta.decide?.('never', {}, [{name: 'a', when: () => false, run: () => 1}]), undefined);
+    t.equal(meta.decisions?.[0]?.chosen, 'none', 'and it is recorded as `none` rather than lost');
+    t.end();
+});
+
+t.test('each predicate is evaluated once', t => {
+    const meta: IMeta = {};
+    createAttachCheckpoint('test')(meta);
+    let evaluations = 0;
+    meta.decide?.('counting', {}, [
+        {
+            name: 'only',
+            when: () => {
+                evaluations++;
+                return true;
+            },
+            run: () => 'taken',
+        },
+    ]);
+    t.equal(evaluations, 1, 'the `run` is wrapped, not the predicate re-evaluated');
+    t.end();
+});
+
+t.test('a branch that throws records nothing', t => {
+    const meta: IMeta = {};
+    createAttachCheckpoint('test')(meta);
+    t.throws(
+        () =>
+            meta.decide?.('boom', {}, [
+                {
+                    name: 'a',
+                    when: () => true,
+                    run: () => {
+                        throw new Error('handler failed');
+                    },
+                },
+            ]),
+        /handler failed/,
+        'the failure is not swallowed',
+    );
+    t.notOk(
+        meta.decisions,
+        'a decision that never completed is not a decision, so nothing is recorded',
+    );
+    t.end();
+});
+
+t.test('attaching twice does not replace a handle already there', t => {
+    const meta: IMeta = {};
+    const attach = createAttachCheckpoint('test');
+    attach(meta);
+    const first = meta.decide;
+    attach(meta);
+    t.equal(meta.decide, first, 'a dispatch that was already prepared is left alone');
+    t.end();
+});

package/src/checkpoint.ts

@@ -1,7 +1,10 @@
-import type {CheckpointFn, IMeta} from '@feasibleone/blong/types';
+import type {CheckpointFn, DecideFn, IMeta} from '@feasibleone/blong/types';
+import {vocabulary} from '@feasibleone/semantic-log/attachable';
 
 /**
- * Records a checkpoint in the $meta.checkpoints array.
+ * Records a checkpoint in the $meta.checkpoints array, and announces it as a progress
+ * point (PRD R26).
+ *
  * Uses `this` binding — works correctly when called as
  * $meta.checkpoint?.('name', data) with optional chaining.
  */
@@ -11,22 +14,65 @@ const checkpoint: CheckpointFn = function (this: IMeta, name: string, data?: unk
         data,
         timestamp: Date.now(),
     });
+    // The same moment is announced to the log, so a checkpoint reaches the record the
+    // sequence diagram is drawn from rather than only the list a test asserts on. The
+    // vocabulary degrades to nothing where no emitter is attached, so this is one call
+    // and never a way for a dispatch path to import the emitter's ambient scope (F-197).
+    vocabulary.point(name, data);
 };
 
 /**
- * Attaches the checkpoint function to $meta if not already present.
- * The function uses `this` to record into the $meta it's called on.
+ * Takes a branch, and keeps the rationale on the invocation that took it (PRD R11/R26).
+ *
+ * `this`-bound like {@link checkpoint}. The branch's `run` is *wrapped* rather than the
+ * predicates re-evaluated: a predicate with a side effect must run exactly once, and the
+ * decision recorded has to be the one the code actually took. A branch whose `run` throws
+ * records nothing — the throw propagates before the push, because a decision that never
+ * completed is not a decision.
  */
-export function attachCheckpoint($meta: IMeta): void {
-    $meta.checkpoint ??= checkpoint;
-}
+const decide: DecideFn = function <T>(
+    this: IMeta,
+    discriminator: string,
+    values: Record<string, unknown>,
+    branches: ReadonlyArray<{
+        name: string;
+        when: (values: Record<string, unknown>) => boolean;
+        run: () => T;
+    }>,
+): T | undefined {
+    let chosen: string | undefined;
+    const wrapped = branches.map(branch => ({
+        ...branch,
+        run: () => {
+            chosen = branch.name;
+            return branch.run();
+        },
+    }));
+    const result = vocabulary.decide<T>(discriminator, values, wrapped);
+    (this.decisions ??= []).push({
+        discriminator,
+        candidates: branches.map(branch => branch.name),
+        chosen: chosen ?? 'none',
+        values,
+    });
+    return result;
+};
 
 /**
- * Returns an attachCheckpoint function when checkpoint mode is enabled,
- * or undefined for production (zero overhead via optional chaining).
+ * Attach the framework's progress-point handles to a dispatch's `$meta`.
+ *
+ * `decide` is attached in **every** mode: it selects a branch, so a missing one would skip
+ * the work rather than cost a note. `checkpoint` is attached only where points are
+ * recorded, which is what keeps its `?.` call free in production.
  */
 export function createAttachCheckpoint(
     mode: 'test' | 'debug' | 'production',
-): ((meta: IMeta) => void) | undefined {
-    return mode === 'production' ? undefined : attachCheckpoint;
+): (meta: IMeta) => void {
+    const recording = mode !== 'production';
+    return (meta: IMeta): void => {
+        meta.decide ??= decide;
+        if (recording) {
+            meta.checkpoint ??= checkpoint;
+        }
+    };
 }

package/src/orchestrator/common/dispatch.ts

@@ -1,5 +1,5 @@
 import {orchestrator, type IMeta} from '@feasibleone/blong/types';
-import {legName, recordedCall} from '../../lib.ts';
+import {recordedCall} from '../../lib.ts';
 import {declareCall, namespaceOf} from '../../semanticContext.ts';
 
 export default orchestrator<{destination?: string; appendNamespace?: string}>(({remote}) => ({
@@ -35,10 +35,11 @@ export default orchestrator<{destination?: string; appendNamespace?: string}>(({
                 // name would credit the hop to whichever namespace happened to be served
                 // alongside it.
                 //
-                // The leg is spelled as every other leg is, `<caller>.<target>.<method>`:
-                // slash routing is the wire form only, and a `/` in an id is flattened to `-`
-                // by the leg grammar, which would hide the target the arrow names.
-                const declared = legName(forwarded);
+                // The leg is the method the forwarded call reaches its destination with — the
+                // wire name, slash and all (`db/gateway.bundle.find`): that is the method the
+                // callee strips back to, and a label that dotted it would no longer be the name
+                // the call was made by. Who made it is stated beside the method, not inside it.
+                const declared = forwarded;
                 const forward = async (): Promise<unknown[] | undefined> =>
                     (await recordedCall(this, declared, () =>
                         remote.dispatch(...params, {...$meta, method: forwarded}),

package/src/registry.lib.test.ts

@@ -0,0 +1,97 @@
+/**
+ * The `lib` a handler is built with (PRD R26).
+ *
+ * `blongLib` is spread into `lib` first, so a name the library exports cannot silently
+ * replace a handle the framework injects: `blongLib` exports `snapshot` (a chain step) and
+ * used to export `checkpoint` for it, an unrelated thing that shares a word with the
+ * runtime's milestone handle, so the spread used to sit after the injections. The order
+ * is the invariant, so it is pinned here rather than left to a comment — together with
+ * the mode-gated `assert`, the other member whose presence the mode decides.
+ */
+import * as blongLib from '@feasibleone/blong-lib';
+import type {ILib} from '@feasibleone/blong/types';
+import {vocabulary} from '@feasibleone/semantic-log/attachable';
+import t from 'tap';
+import Registry from './Registry.ts';
+
+// Minimal stand-ins: `_createHandlers` only reads the error factory, the platform's
+// timing and the api schema, and closes over the rest.
+const components = {
+    log: {logger: () => ({info() {}, error() {}, warn() {}, debug() {}})},
+    error: {register: () => () => undefined},
+    rpcServer: {},
+    remote: {remote: () => ({})},
+    gateway: {},
+    local: {},
+    resolution: {},
+    watch: {},
+    apiSchema: {},
+    platform: {context: {}, timing: () => undefined},
+};
+
+/** Run one handler through the factory and hand back the `lib` it was given. */
+async function captureLib(mode: 'test' | 'debug' | 'production'): Promise<ILib> {
+    const registry = new Registry({checkpointMode: mode}, components as never);
+    let lib: ILib | undefined;
+    await (
+        registry as unknown as {
+            _createHandlers(handlers: unknown, port: object | undefined): Promise<unknown>;
+        }
+    )._createHandlers(
+        [
+            async (params: {lib: ILib}) => {
+                lib = params.lib;
+            },
+        ],
+        undefined,
+    );
+    if (lib === undefined) {
+        throw new Error('the handler factory was not called');
+    }
+    return lib;
+}
+
+t.test('a handler is handed the framework branch helper, not a name the library owns', async t => {
+    const lib = await captureLib('test');
+    t.type(lib.decide, 'function', 'the branch helper is always injected');
+    t.equal(
+        lib.decide,
+        vocabulary.decide,
+        'and it is the attachable one, so a realm needs no dependency on the log library',
+    );
+    t.equal(lib.checkpoint, vocabulary.point, 'the milestone handle is the ambient one');
+    t.notOk(
+        'checkpoint' in blongLib,
+        'the library does not define that name, so the spread cannot replace it',
+    );
+    t.notOk('decide' in blongLib, 'nor the branch helper');
+    t.notOk('assert' in blongLib, 'nor the assertion handle');
+    t.end();
+});
+
+t.test('checkpoint follows the mode, while decide is always there', async t => {
+    t.type((await captureLib('test')).checkpoint, 'function', 'test mode reports points');
+    t.type((await captureLib('debug')).checkpoint, 'function', 'debug mode reports them too');
+    t.equal(
+        (await captureLib('production')).checkpoint,
+        undefined,
+        'and production leaves the slot empty, so `lib.checkpoint?.()` is one call',
+    );
+    t.type(
+        (await captureLib('production')).decide,
+        'function',
+        'a branch is selected in production as anywhere else',
+    );
+    t.end();
+});
+
+t.test('assert is there only where a failure may be expected', async t => {
+    t.type((await captureLib('test')).assert, 'function', 'test mode asserts');
+    t.type((await captureLib('debug')).assert, 'function', 'debug mode asserts too');
+    t.equal(
+        (await captureLib('production')).assert,
+        undefined,
+        'and production leaves the slot empty, so `lib.assert?.(…)` is one call',
+    );
+    t.end();
+});

package/src/semanticContext.test.ts

@@ -8,13 +8,14 @@ import {
     callsFor,
     capabilityOf,
     currentIdentity,
-    enterCapability,
+    decide,
     declareCall,
+    enterCapability,
     enterRequestFlow,
     inboundIdentities,
     isFlowId,
-    legIdFor,
     namespaceOf,
+    point,
     runInFlow,
 } from './semanticContext.ts';
 
@@ -32,6 +33,30 @@ function inbound(fields: string): IMeta {
     return {mtid: 'request', method: 'm', forward: {'x-semantic-trace': fields}};
 }
 
+t.test('the progress-point handles report through whichever vocabulary is attached', t => {
+    // PRD R26: a realm or a bootstrap reaches these through this module rather than through the
+    // emitter, so what they must be is the *façade's* functions — the ones that degrade when
+    // nothing is attached (this module is on the browser's path too). With the vocabulary attached
+    // above, the same calls reach the emitter itself.
+    point('handler-created', {by: 'semanticContext.test'});
+    t.same(
+        vocabulary.takePoints(),
+        [{name: 'handler-created', data: {by: 'semanticContext.test'}}],
+        'a point reported here is taken by the attached vocabulary',
+    );
+    const chosen = decide('route', {}, [
+        {name: 'a', when: () => false, run: () => 'a'},
+        {name: 'b', when: () => true, run: () => 'b'},
+    ]);
+    t.equal(chosen, 'b', 'and a branch taken here still selects');
+    t.equal(
+        vocabulary.takeDecision()?.chosen,
+        'b',
+        'while its rationale reaches the vocabulary too',
+    );
+    t.end();
+});
+
 t.test('a request enters its flow before the hooks that may reject it', async t => {
     // The enter-style entry. A gateway request is decided in two phases with a
     // framework boundary between them: the auth and metering hooks run before the
@@ -40,7 +65,11 @@ t.test('a request enters its flow before the hooks that may reject it', async t
     await (async () => {
         const published = enterRequestFlow({}, 'access.role.find');
         t.equal(isFlowId(currentContext().flow?.id), true, 'a flow is minted and entered');
-        t.equal(currentContext().flow?.kind, 'access.role.find', 'named for the path it arrived on');
+        t.equal(
+            currentContext().flow?.kind,
+            'access.role.find',
+            'named for the path it arrived on',
+        );
         t.equal(
             published['x-semantic-trace']?.includes(`flow=${currentContext().flow?.id ?? ''}`),
             true,
@@ -84,31 +113,61 @@ t.test('a flow id is a ULID and nothing else', t => {
 
 t.test('identity is read off the forwarded header bag', t => {
     t.same(inboundIdentities(undefined), {}, 'a call with no meta carries nothing');
-    t.same(inboundIdentities({mtid: 'request', method: 'm'}), {}, 'and so does one with no forward block');
     t.same(
-        inboundIdentities(inbound(`trace=tr-1,flow=${FLOW},leg=access.db.party.subject.find,to=party,seq=1.2`)),
-        {trace: 'tr-1', flow: FLOW, leg: 'access.db.party.subject.find', to: 'party', seq: '1.2'},
+        inboundIdentities({mtid: 'request', method: 'm'}),
+        {},
+        'and so does one with no forward block',
+    );
+    t.same(
+        inboundIdentities(
+            inbound(
+                `trace=tr-1,flow=${FLOW},leg=party.subject.find,from=access.db,to=party,seq=1.2`,
+            ),
+        ),
+        {
+            trace: 'tr-1',
+            flow: FLOW,
+            leg: 'party.subject.find',
+            from: 'access.db',
+            to: 'party',
+            seq: '1.2',
+        },
         'a full set is read back out',
     );
     t.end();
 });
 
-t.test('a leg is named by dotting the caller and the method', t => {
+t.test('a leg is the method, and the caller travels beside it', t => {
+    // The method is what a diagram labels the arrow with, so it is the leg id verbatim -
+    // including a forwarded hop's slash (`db/party.subject.find`), which is the name the
+    // callee strips back to. The caller is its own identity: repeating it in the label said
+    // what the arrow already said, and the two are read for different things (D-249).
+    t.equal(namespaceOf('party.subject.find'), 'party', 'the method names the unit it reaches');
     t.equal(
-        legIdFor('access.db', 'party.subject.find'),
-        'access.db.party.subject.find',
-        'a port id and a method join with a dot',
+        namespaceOf('db/party.subject.find'),
+        'db',
+        'and a forwarded hop names the one it forwards to',
     );
     t.equal(
-        legIdFor('srv/subject', 'party:subject'),
-        'srv-subject.party-subject',
-        'characters the grammar forbids are flattened rather than rejected',
+        vocabulary.isLegId('db/party.subject.find'),
+        true,
+        'a forwarded hop is a lawful leg id',
     );
+    t.equal(
+        vocabulary.isServiceName('access.db'),
+        true,
+        'and a caller is named by the same grammar',
+    );
+    t.equal(vocabulary.isServiceName('access/db'), false, 'without the slash a method may carry');
     t.end();
 });
 
 t.test('a participant is the first segment of the method', t => {
-    t.equal(namespaceOf('party.subject.find'), 'party', 'a dotted method names its namespace first');
+    t.equal(
+        namespaceOf('party.subject.find'),
+        'party',
+        'a dotted method names its namespace first',
+    );
     t.equal(namespaceOf('db/party.subject.find'), 'db', 'and so does a rewritten destination');
     t.equal(namespaceOf('party'), 'party', 'a method in the root namespace is its own');
     t.end();
@@ -121,13 +180,13 @@ t.test('an outermost entry mints a flow and publishes it for the calls inside it
         identity: currentIdentity(),
     }));
     t.equal(isFlowId(seen.identity.flow), true, 'the entry has an execution id');
-    t.equal(seen.context.flow?.kind, 'access.user.find', 'whose kind is the method it was addressed to');
-    t.equal(typeof seen.context.trace, 'string', 'and it is correlated by a trace');
     t.equal(
-        seen.identity.leg,
-        undefined,
-        'the entry itself is not a call, so it declares no leg',
+        seen.context.flow?.kind,
+        'access.user.find',
+        'whose kind is the method it was addressed to',
     );
+    t.equal(typeof seen.context.trace, 'string', 'and it is correlated by a trace');
+    t.equal(seen.identity.leg, undefined, 'the entry itself is not a call, so it declares no leg');
     t.match(
         meta.forward?.['x-semantic-trace'] ?? '',
         new RegExp(`flow=${seen.identity.flow}`),
@@ -155,8 +214,16 @@ t.test('a B3 trace that cannot be used is minted instead', t => {
         method: 'm',
         forward: {'x-b3-traceid': 42},
     } as unknown as IMeta;
-    t.not(runInFlow(empty, 'm', () => currentContext().trace), '', 'an empty trace is not a trace');
-    t.not(runInFlow(wrongType, 'm', () => currentContext().trace), 42, 'nor is one that is not a string');
+    t.not(
+        runInFlow(empty, 'm', () => currentContext().trace),
+        '',
+        'an empty trace is not a trace',
+    );
+    t.not(
+        runInFlow(wrongType, 'm', () => currentContext().trace),
+        42,
+        'nor is one that is not a string',
+    );
     t.end();
 });
 
@@ -199,13 +266,15 @@ t.test('an inbound call carrying no identity is an outermost entry', t => {
 });
 
 t.test('an inbound identity the grammar refuses is dropped, never repaired', t => {
-    const badSeq = adoptInbound(
-        inbound(`flow=${FLOW},leg=payer.quote.rates,seq=1.`),
-        'm',
-        () => currentIdentity(),
+    const badSeq = adoptInbound(inbound(`flow=${FLOW},leg=payer.quote.rates,seq=1.`), 'm', () =>
+        currentIdentity(),
     );
     t.equal(badSeq.leg, 'payer.quote.rates', 'a lawful leg is adopted');
-    t.equal(badSeq.seq, undefined, 'but a position that is not one is left out rather than guessed');
+    t.equal(
+        badSeq.seq,
+        undefined,
+        'but a position that is not one is left out rather than guessed',
+    );
 
     const badLeg = adoptInbound(inbound(`flow=${FLOW},leg=!`), 'm', () => currentIdentity());
     t.equal(badLeg.flow, FLOW, 'the execution is still adopted');
@@ -218,12 +287,16 @@ t.test('an inbound identity the grammar refuses is dropped, never repaired', t =
 
 t.test('a call made outside any flow is not declared', t => {
     const meta: IMeta = {mtid: 'request', method: 'm'};
-    t.equal(declareCall('access.db', 'party.subject.find', () => 'ran', meta), 'ran', 'the call still runs');
+    t.equal(
+        declareCall('access.db', 'party.subject.find', () => 'ran', meta),
+        'ran',
+        'the call still runs',
+    );
     t.equal(meta.forward, undefined, 'and nothing is published onto a meta no flow holds');
     t.end();
 });
 
-t.test('a call inside a flow is named for the caller that makes it', t => {
+t.test('a call inside a flow is named by its method, with the caller beside it', t => {
     const meta: IMeta = {mtid: 'request', method: 'access.user.find'};
     // Read the scope from inside the declaration: the leg only exists while the
     // call it names is being made.
@@ -237,8 +310,13 @@ t.test('a call inside a flow is named for the caller that makes it', t => {
     );
     t.equal(
         seen.identity.leg,
-        'access.db.party.subject.find',
-        'the leg names the caller and the method it called',
+        'party.subject.find',
+        'the leg is the method the call is made by — what a diagram labels the arrow with',
+    );
+    t.equal(
+        seen.context.legFrom,
+        'access.db',
+        'and the unit that made it is its own identity, not part of the label',
     );
     t.match(String(seen.identity.seq), /^[0-9]+$/, 'and takes the first position in the caller');
     t.equal(
@@ -248,8 +326,8 @@ t.test('a call inside a flow is named for the caller that makes it', t => {
     );
     t.match(
         meta.forward?.['x-semantic-trace'] ?? '',
-        /leg=access\.db\.party\.subject\.find/,
-        'and the callee is handed the call it is part of',
+        /leg=party\.subject\.find,from=access\.db,to=party/,
+        'and the callee is handed the call it is part of, both ends stated',
     );
     t.end();
 });
@@ -259,7 +337,11 @@ t.test('a call declared without a meta still binds the caller scope', t => {
     const leg = runInFlow(meta, 'm', () =>
         declareCall('access.db', 'party.subject.find', () => currentIdentity().leg),
     );
-    t.equal(leg, 'access.db.party.subject.find', 'the leg is bound whether or not there is a meta to publish on');
+    t.equal(
+        leg,
+        'party.subject.find',
+        'the leg is bound whether or not there is a meta to publish on',
+    );
     t.end();
 });
 
@@ -281,9 +363,17 @@ t.test('the scope a caller is in can be asked about', t => {
 
 t.test('a flow records calls unless something decided otherwise', t => {
     configureCallTrace(undefined);
-    t.equal(callsFor(undefined, 'access.access.find'), true, 'nothing decided and nothing configured');
+    t.equal(
+        callsFor(undefined, 'access.access.find'),
+        true,
+        'nothing decided and nothing configured',
+    );
     configureCallTrace({enabled: false});
-    t.equal(callsFor(undefined, 'access.access.find'), false, 'the configuration can opt everything out');
+    t.equal(
+        callsFor(undefined, 'access.access.find'),
+        false,
+        'the configuration can opt everything out',
+    );
     configureCallTrace({off: ['payment']});
     t.equal(callsFor(undefined, 'payment.transfer.prepare'), false, 'or one entry');
     configureCallTrace(undefined);

package/src/semanticContext.ts

@@ -18,15 +18,15 @@
  * - **A participant is an RPC namespace** — `party`, `db`, `subject`. It is what
  *   a call targets, what becomes a Kubernetes service, and what the emitter
  *   derives for a record from the method name, so the two agree by construction.
- * - **A leg is one call site**, named `<caller>.<called method>`, where the caller
- *   is the logical unit that made the call — the namespace it answers for, not the
- *   process it runs in. The emitter's own grammar allows letters, digits and `.`,
- *   `-`, `_` only, so the plan's `a -> b` arrow is written as a dot path and anything
- *   else in a caller or method name is flattened to `-`. The id is declared by the
- *   caller, against the namespace it **aimed at** — which is the namespace the callee
- *   will derive for itself, because blong's destination rewrite (`party.subject.find`
- *   becomes `db/party.subject.find`) happens *inside* the receiving port, as a call of
- *   its own.
+ * - **A leg is one call site**, named by the method the call reaches its callee with —
+ *   `party.subject.find`, or `db/party.subject.find` once blong's destination rewrite has
+ *   prefixed the namespace it forwards to. The unit that made the call travels beside it as
+ *   its own identity (`legFrom`, with `legTo` naming the receiver it aimed at), because a
+ *   diagram draws the ends from the identity and the label from the method: repeating the
+ *   caller in the label said what the arrow already said, and made every label longer than
+ *   the arrow it sat on (D-249). The caller is the logical unit the port answers for — never
+ *   the process it runs in — and the grammar's charset is why a `/` is lawful in a method
+ *   and not in a participant name.
  *
  * ## Propagation, and where it rides
  *
@@ -118,6 +118,29 @@ export const enterCapability = vocabulary.enterCapability;
  */
 export const withStep = step;
 
+/**
+ * Report a progress point, or take a branch, from code that holds no `$meta`.
+ *
+ * Re-exported beside `withStep` for the same reason it is: a realm or a bootstrap that already
+ * reaches this module for its scope machinery should not have to import the emitter to say what
+ * the logic was doing (PRD R26). Both degrade when nothing is attached — `point` to nothing,
+ * `decide` to the selection alone, because a branch has to be taken either way.
+ */
+export const point = vocabulary.point;
+export const decide = vocabulary.decide;
+
+/**
+ * Take the progress announced in the scope a handler ran in, and announce it again.
+ *
+ * Both halves of one thing, and both used by the same caller: the adapter reads what its
+ * handler announced when the handler returns (`takeProgress`) and stages it so the record the
+ * call answers with carries it (`attachProgress`) — the only route a realm handler's points
+ * and branches have to a record, since the records of a call are the framework's (PRD R26/R27).
+ */
+export const takeProgress = vocabulary.takeProgress;
+export const attachProgress = vocabulary.attachProgress;
+export const beginProgress = vocabulary.beginProgress;
+
 /** The capability decided for this scope, or `undefined` when nothing decided it. */
 export const capabilityOf = vocabulary.capabilityState;
 
@@ -157,12 +180,6 @@ export function inboundIdentities(meta: IMeta | undefined): Identities {
     return readIdentities((meta?.forward ?? {}) as Record<string, unknown>);
 }
 
-/** A leg id as the emitter's grammar allows it: `<caller>.<method>`, flattened. */
-export function legIdFor(caller: string, method: string): string {
-    const flatten = (text: string): string => text.replace(/[^A-Za-z0-9._-]/g, '-');
-    return `${flatten(caller)}.${flatten(method)}`;
-}
-
 /** The participant a call targets: the first segment of its method. */
 export function namespaceOf(method: string): string {
     const at = method.search(/[./]/);
@@ -317,22 +334,25 @@ export function adoptInbound<T>(meta: IMeta, kind: string, fn: () => T): T {
  * emitter refuses to invent an execution to hold a leg (D3) and inventing one here
  * would put a lie in the data.
  *
- * `caller` is the port making the call and `method` the wire name it is calling —
- * including any destination the caller has already applied, so the declaration
- * matches the receiver the call will actually reach.
+ * `caller` is the **logical unit** that makes the call — the namespace a port serves, not its
+ * port id and not the process it runs in — and `method` is the wire name the call is being made
+ * by, including any destination the caller has already applied, so the declaration matches the
+ * receiver the call will actually reach. The two travel as separate identities: the method is
+ * the label a diagram draws on the arrow, the caller is the arrow's source, and repeating the
+ * caller in the label said what the arrow already said (D-249).
  */
 export function declareCall<T>(caller: string, method: string, fn: () => T, meta?: IMeta): T {
     if (currentContext().flow === undefined) {
         return fn();
     }
-    const id = legIdFor(caller, method);
+    const id = method;
     const to = namespaceOf(method);
-    if (!isLegId(id) || !isServiceName(to)) {
-        // A port id or method the grammar cannot hold: the call still runs, it is
+    if (!isLegId(id) || !isServiceName(caller) || !isServiceName(to)) {
+        // A caller or a method the grammar cannot hold: the call still runs, it is
         // simply not named. Throwing here would fail a request over its telemetry.
         return fn();
     }
-    return bindLeg({id, to}, () => {
+    return bindLeg({id, from: caller, to}, () => {
         if (meta !== undefined) {
             meta.forward = {...meta.forward, ...identityHeaders()};
         }