humanish 0.110.3 → 0.111.0

package/dist/study/url-credentials.js

@@ -1,7 +1,7 @@
 // Every URL a study config declares, checked for a credential. Route planners call it, since a
 // library caller's config skips the parser that refuses these first.
-import { rosterOf } from "./parse/actors.js";
 import { entryCredentialReason, urlCredentialReason } from "./parse/url-credentials.js";
+import { participantList } from "./study-fields.js";
 /**
  * The first URL in `config` that carries a credential, with why: the subject's app, serve and
  * public surface URLs, and each participant's target and entry.
@@ -16,14 +16,14 @@ export function studyUrlCredentialReason(config) {
             ? undefined
             : urlCredentialReason("subject.serve.url", subject.serve.url),
         ...(subject.product?.publicSurfaces ?? []).map((surface) => () => urlCredentialReason("subject.product.publicSurfaces", surface)),
-        ...config.actors.flatMap((actor) => (rosterOf(actor) ?? []).flatMap((participant, index) => [
+        ...(participantList(config) ?? []).flatMap((participant, index) => [
             () => participant.target === undefined
                 ? undefined
                 : urlCredentialReason(`participants[${index}].target`, participant.target),
             () => participant.entry === undefined
                 ? undefined
                 : entryCredentialReason(`participants[${index}].entry`, participant.entry),
-        ])),
+        ]),
     ];
     for (const reason of reasons) {
         const found = reason();

package/dist/study/validation.d.ts

@@ -7,12 +7,14 @@ import type { StudyConfig } from "./types.js";
  */
 export declare function computerUseValidationReason(config: StudyConfig): string | null;
 /**
- * Cross-validate a `topology: shared-world` declaration. Returns the failure message, or
+ * Cross-validate a `route: shared-world` declaration. Returns the failure message, or
  * null when the one shared-world route can run it: the external-public checks for an app-url
  * subject, the provisioned checks otherwise. Enforced at parse and again by the route, since
  * runStudyWith takes a config that skipped the parser.
  */
 export declare function sharedWorldValidationReason(config: StudyConfig): string | null;
+/** SMTP capture runs only where each participant has its own world, so a shared world refuses it. */
+export declare function smtpValidationReason(config: StudyConfig): string | undefined;
 /**
  * Declared capture devices must be implemented by the selected execution route.
  * Unsupported backends pass false when called directly, where the declared
@@ -32,14 +34,6 @@ export declare function taskProtocolValidationReason(config: StudyConfig, suppor
  * at parse and again on the computer-use and scripted-browser routes for library callers.
  */
 export declare function cloneTargetValidationReason(config: StudyConfig): string | null;
-/**
- * Refuse a positive `scenario.caps.maxUsd` or `maxTotalUsd` on a computer-use study.
- * `scenario.caps` belongs to the terminal route; the computer-use route stops on `execution.caps`,
- * so a dollar figure here would read as a cap while the study ran uncapped. Zero spends nothing
- * either way and stays a warning. Enforced at parse and again on the computer-use routes for
- * library callers.
- */
-export declare function scenarioCapsValidationReason(config: StudyConfig): string | null;
 /** Refuse a claimed output bound when the route cannot pass it to the first-party provider. */
 export declare function outputTokenLimitValidationReason(config: StudyConfig): string | null;
 /**
@@ -58,7 +52,7 @@ export declare function concurrentSharedWorldValidationReason(config: StudyConfi
  * it rejects every provisioned-subject field (serve/state.seed/state.checkpoint/exposure/clone/repos
  * are inert with no sandbox, so they fail closed), and requires a
  * non-loopback appUrl + allowPublicTargets + the operator-ownership attestation subject.publicTarget +
- * concurrency >= 2 + an actors[0].lanes roster of ≥2 with exactly one host participant. The getHost synthetic
+ * concurrency >= 2 + a `participants` list of ≥2 with exactly one host participant. The getHost synthetic
  * gate is deliberately unreachable here (there is no internet-reachable harness-owned URL to attest).
  * Enforced at parse and re-enforced in the engine (runStudyWith takes a config that skipped the parser).
  */

package/dist/study/validation.js

@@ -1,8 +1,9 @@
 import { isMaxOutputTokens } from "../actors/output-token-limit.js";
-import { PARTICIPANT_ID_MAX_CHARS, PARTICIPANT_ID_PATTERN, focusOf, rosterOf, } from "./parse/actors.js";
+import { PARTICIPANT_ID_MAX_CHARS, PARTICIPANT_ID_PATTERN } from "./parse/actors.js";
 import { isHttpUrl, isLoopbackUrl } from "./parse/subject.js";
 import { declaredTargets } from "./plan-participants.js";
 import { actorResolvesToComputerUse, computerUseParticipantCount, MAX_COMPUTER_USE_PARTICIPANTS, registeredComputerUseActors, resolveEntryUrl, isComputerUseComposition, isScriptedBrowserComposition, isSharedWorldComposition, isTerminalProductComposition, } from "./routing.js";
+import { actorOf, participantList, declaresSharedWorld } from "./study-fields.js";
 /**
  * Cross-validate the computer-use fan-out declaration (`per-lane-worlds`). Returns the failure
  * message, or null when valid. The parser enforces it, and runStudyWith checks it again for a config
@@ -10,39 +11,32 @@ import { actorResolvesToComputerUse, computerUseParticipantCount, MAX_COMPUTER_U
  * validity, unique ids) first, then the route-scoped XOR, cap and policy checks.
  */
 export function computerUseValidationReason(config) {
-    const actor = config.actors[0];
-    const roster = rosterOf(actor);
+    const roster = participantList(config);
     const structuralReason = rosterStructuralValidationReason(config);
     if (structuralReason) {
         return structuralReason;
     }
     // clone.fanout is a declared behavior change: rejected on the computer-use route (was
-    // inert-warned). Fan-out is declared via `actors[0].count` or `actors[0].lanes`;
-    // subject.clone.fanout never applied here.
+    // inert-warned). Fan-out is declared with `participants`; subject.clone.fanout never applied
+    // here.
     if (config.subject.clone?.fanout !== undefined) {
-        return "`subject.clone.fanout` is not used on the computer-use route: declare fan-out with actors[0].count (homogeneous) or actors[0].lanes (a roster of participants). (No current route reads clone.fanout.)";
+        return "`subject.clone.fanout` is not used on the computer-use route: declare fan-out with participants (homogeneous) or participants (a roster of participants). (No current route reads clone.fanout.)";
     }
     if (roster !== undefined) {
-        if (actor?.count !== undefined) {
-            return "Set either `actors[0].count` (identical participants) or `actors[0].lanes` (a roster of distinct participants), not both.";
-        }
-        if (focusOf(actor) !== undefined) {
-            return "actors[0].laneFocus and actors[0].lanes are mutually exclusive: each roster entry's `instruction` is the fan-out steer; laneFocus is the steer for a single participant.";
-        }
         if (config.execution?.desktop?.resolution !== undefined &&
             roster.some((entry) => entry.device !== undefined)) {
-            return "actors[0].lanes[].device and a raw execution.desktop.resolution are mutually exclusive: a per-participant device preset and a single hand-set resolution cannot both govern participant geometry.";
+            return "participants[].device and a raw execution.desktop.resolution are mutually exclusive: a per-participant device preset and a single hand-set resolution cannot both govern participant geometry.";
         }
         const targeted = roster.filter((entry) => entry.target !== undefined);
         if (targeted.length > 0) {
             if (config.subject.source !== "app-url") {
-                return "`actors[0].lanes[].target` works only on app-url computer-use studies. Clone, shared-world and local-app studies set each participant's entry URL themselves; remove `target`.";
+                return "`participants[].target` works only on app-url computer-use studies. Clone, shared-world and local-app studies set each participant's entry URL themselves; remove `target`.";
             }
             if (roster.some((entry) => entry.entry !== undefined)) {
-                return "actors[0].lanes[].target and actors[0].lanes[].entry are mutually exclusive: target is an app-url fan-out browser URL; entry is a shared-world same-origin participant path.";
+                return "participants[].target and participants[].entry are mutually exclusive: target is an app-url fan-out browser URL; entry is a shared-world same-origin participant path.";
             }
             if (targeted.length !== roster.length) {
-                return "When any actors[0].lanes[].target is declared, every participant in the roster must declare target; this keeps the setup-produced target contract explicit and prevents accidental mixed worlds.";
+                return "When any participants[].target is declared, every participant in the roster must declare target; this keeps the setup-produced target contract explicit and prevents accidental mixed worlds.";
             }
         }
     }
@@ -53,14 +47,14 @@ export function computerUseValidationReason(config) {
     // Public targets fan out into N independent worlds driving the same public app, which is an
     // ambiguous shared-world-ish shape, not a per-participant target swarm. Permit N>1 public runs only
     // when every roster entry declares its own target, making the adapter-owned topology explicit. But when
-    // `subject.topology: shared-world` is also declared, N participants against one public target is the
+    // `route: shared-world` is also declared, N participants against one public target is the
     // external-public shared-world topology, so route it there (a real public deployment
     // as the shared plane) instead of refusing; externalPublicSharedWorldValidationReason then applies.
     if (participantCount > 1 &&
         config.policies?.allowPublicTargets === true &&
         declaredTargets(config).length === 0 &&
-        config.subject.topology !== "shared-world") {
-        return "`policies.allowPublicTargets` with more than one participant sends them all to one public app, which is a shared world. Set `subject.topology: shared-world` to run them together there, give each `actors[0].lanes[]` entry its own `target`, or run one participant.";
+        !declaresSharedWorld(config)) {
+        return "`policies.allowPublicTargets` with more than one participant sends them all to one public app, which is a shared world. Set `route: shared-world` to run them together there, give each `participants[]` entry its own `target`, or run one participant.";
     }
     return null;
 }
@@ -69,15 +63,15 @@ export function computerUseValidationReason(config) {
  * public TypeScript/JavaScript API instead of parseStudy.
  */
 function rosterStructuralValidationReason(config) {
-    const roster = rosterOf(config.actors[0]);
+    const roster = participantList(config);
     const seenIds = new Set();
     if (roster !== undefined) {
         if (!Array.isArray(roster) || roster.length === 0) {
-            return "actors[0].lanes must be a non-empty array when set.";
+            return "participants must be a non-empty array when set.";
         }
         for (const [index, entry] of roster.entries()) {
             if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
-                return `actors[0].lanes[${index}] must be an object.`;
+                return `participants[${index}] must be an object.`;
             }
             const id = entry.id;
             if (id === undefined) {
@@ -86,10 +80,10 @@ function rosterStructuralValidationReason(config) {
             if (typeof id !== "string" ||
                 !PARTICIPANT_ID_PATTERN.test(id) ||
                 id.length > PARTICIPANT_ID_MAX_CHARS) {
-                return `actors[0].lanes[${index}].id must be a public-safe path token matching ${PARTICIPANT_ID_PATTERN} and at most ${PARTICIPANT_ID_MAX_CHARS} chars.`;
+                return `participants[${index}].id must be a public-safe path token matching ${PARTICIPANT_ID_PATTERN} and at most ${PARTICIPANT_ID_MAX_CHARS} chars.`;
             }
             if (seenIds.has(id)) {
-                return `actors[0].lanes ids must be unique (duplicate "${id}").`;
+                return `participants ids must be unique (duplicate "${id}").`;
             }
             seenIds.add(id);
         }
@@ -97,7 +91,7 @@ function rosterStructuralValidationReason(config) {
     return null;
 }
 /**
- * Cross-validate a `topology: shared-world` declaration. Returns the failure message, or
+ * Cross-validate a `route: shared-world` declaration. Returns the failure message, or
  * null when the one shared-world route can run it: the external-public checks for an app-url
  * subject, the provisioned checks otherwise. Enforced at parse and again by the route, since
  * runStudyWith takes a config that skipped the parser.
@@ -109,8 +103,8 @@ export function sharedWorldValidationReason(config) {
 }
 /**
  * The structural checks every provisioned shared world shares. It requires: a clone or local-tree source + e2b-desktop
- * target + a computer-use actor + a `subject.serve` block + an `actors[0].lanes` roster of ≥2 roles (the
- * roster is the role roster; there is no separate roles[] field), and every role `entry` must resolve
+ * target + a computer-use actor + a `subject.serve` block + a `participants` list of ≥2 (the list
+ * is the role roster; there is no separate roles[] field), and every role `entry` must resolve
  * same-origin (loopback) with serve.url. Fail-closed: a half-declared shared-world is rejected,
  * never silently downgraded.
  */
@@ -120,32 +114,38 @@ function provisionedSharedWorldStructureReason(config) {
         return structuralReason;
     }
     if (config.subject.source !== "clone" && config.subject.source !== "local-tree") {
-        return "`subject.topology: shared-world` needs `subject.source: clone` or `local-tree`, which humanish serves as one seeded app every participant uses, or `app-url` for a public deployment you own.";
+        return "`route: shared-world` needs `subject.source: clone` or `local-tree`, which humanish serves as one seeded app every participant uses, or `app-url` for a public deployment you own.";
     }
     if (config.execution?.target !== "e2b-desktop") {
-        return "`subject.topology: shared-world` requires `execution.target: e2b-desktop`: the role participants drive hosted desktop browsers against one in-sandbox app.";
+        return "`route: shared-world` requires `execution.target: e2b-desktop`: the role participants drive hosted desktop browsers against one in-sandbox app.";
     }
-    if (!actorResolvesToComputerUse(config.actors[0]?.type)) {
-        return `\`subject.topology: shared-world\` requires a registered computer-use actor (one of: ${registeredComputerUseActors().join(", ")}); each role participant runs a computer-use session.`;
+    if (!actorResolvesToComputerUse(actorOf(config)?.type)) {
+        return `\`route: shared-world\` requires a registered computer-use actor (one of: ${registeredComputerUseActors().join(", ")}); each role participant runs a computer-use session.`;
     }
     const serve = config.subject.serve;
     if (!serve) {
-        return "`subject.topology: shared-world` needs `subject.serve` (start and url): humanish starts one copy of the app in the sandbox, and every participant uses it.";
+        return "`route: shared-world` needs `subject.serve` (start and url): humanish starts one copy of the app in the sandbox, and every participant uses it.";
     }
-    const roster = rosterOf(config.actors[0]);
+    const roster = participantList(config);
     if (!roster || roster.length < 2) {
-        return "`subject.topology: shared-world` needs an `actors[0].lanes` roster of at least 2 participants: with one participant there is nobody to interact with.";
+        return "`route: shared-world` needs a `participants` list of at least 2 participants: with one participant there is nobody to interact with.";
     }
     if (!config.subject.state?.checkpoint || config.subject.state.checkpoint.length === 0) {
-        return "`subject.topology: shared-world` needs at least one read-only `subject.state.checkpoint` probe: the checkpoints are how the run shows that participants changed the shared app.";
+        return "`route: shared-world` needs at least one read-only `subject.state.checkpoint` probe: the checkpoints are how the run shows that participants changed the shared app.";
     }
     for (const entry of roster) {
         if (entry.entry !== undefined && resolveEntryUrl(serve.url, entry.entry) === null) {
-            return `actors[0].lanes role "${entry.id ?? "(unnamed)"}".entry must resolve same-origin (loopback) with subject.serve.url (${serve.url}); got "${entry.entry}".`;
+            return `participants role "${entry.id ?? "(unnamed)"}".entry must resolve same-origin (loopback) with subject.serve.url (${serve.url}); got "${entry.entry}".`;
         }
     }
     return null;
 }
+/** SMTP capture runs only where each participant has its own world, so a shared world refuses it. */
+export function smtpValidationReason(config) {
+    return config.comms?.email?.smtp && declaresSharedWorld(config)
+        ? "SMTP capture is not supported yet for shared-world studies. Use the default per-lane-worlds topology for SMTP, or configure supported HTTP email capture for concurrent shared-world studies."
+        : undefined;
+}
 /**
  * Declared capture devices must be implemented by the selected execution route.
  * Unsupported backends pass false when called directly, where the declared
@@ -153,9 +153,7 @@ function provisionedSharedWorldStructureReason(config) {
  */
 export function desktopMediaValidationReason(config, supportsMedia = isComputerUseComposition(config)) {
     if (config.execution?.desktop?.recording !== undefined &&
-        (!supportsMedia ||
-            config.subject.topology === "shared-world" ||
-            config.subject.source === "local-app")) {
+        (!supportsMedia || declaresSharedWorld(config) || config.subject.source === "local-app")) {
         return "execution.desktop.recording is supported only for computer-use participants on independent desktops. Remove the declaration or select a supported route.";
     }
     const media = config.execution?.desktop?.media;
@@ -164,7 +162,7 @@ export function desktopMediaValidationReason(config, supportsMedia = isComputerU
     if (media.microphone !== undefined && media.microphone.source !== "speech") {
         return "execution.desktop.media.microphone.source must be speech. Microphone source-file injection is unsupported.";
     }
-    if (config.subject.topology === "shared-world") {
+    if (declaresSharedWorld(config)) {
         return "execution.desktop.media is unsupported on shared-world routes; declared capture devices would not be provisioned. Use independent computer-use browser participants or remove the declaration.";
     }
     if (!supportsMedia ||
@@ -176,8 +174,10 @@ export function desktopMediaValidationReason(config, supportsMedia = isComputerU
         return "execution.desktop.media requires Chrome or Chromium; Firefox cannot receive the declared synthetic capture device. Set execution.desktop.browser: chrome or chromium.";
     }
     if (media.microphone !== undefined) {
-        if (config.actors.some((actor) => actor.type !== "local-agent" ||
-            (actor.localAgent !== undefined && actor.localAgent !== "codex"))) {
+        const actor = actorOf(config);
+        if (actor !== undefined &&
+            (actor.type !== "local-agent" ||
+                (actor.localAgent !== undefined && actor.localAgent !== "codex"))) {
             return "Participant speech currently requires local-agent with Codex, on a local or hosted desktop.";
         }
         if (config.execution?.target !== "local" && media.camera !== undefined) {
@@ -194,7 +194,7 @@ export function receivingEmailValidationReason(config) {
         !["app-url", "clone", "local-tree"].includes(config.subject.source)) {
         return "Real email receiving requires a hosted computer-use browser study with an app-url, clone, or local-tree subject. Scripted, terminal, desktop-cli and local-app routes are unsupported.";
     }
-    if (config.actors.some((actor) => actor.type === "local-agent")) {
+    if (actorOf(config)?.type === "local-agent") {
         return "Real email receiving is unavailable for local-agent: its host process does not isolate the inbox management credential. Use a hosted first-party computer-use actor.";
     }
     return undefined;
@@ -202,15 +202,8 @@ export function receivingEmailValidationReason(config) {
 /** Refuse task declarations that the selected execution path would discard.
  * Direct runners pass their actual support rather than trusting the config's dispatch shape. */
 export function taskProtocolValidationReason(config, supportsTasks = isComputerUseComposition(config) && !isSharedWorldComposition(config)) {
-    for (const [index, actor] of config.actors.entries()) {
-        if (actor.tasks === undefined)
-            continue;
-        if (index > 0) {
-            return `actors[${index}].tasks is unsupported: current runners consume only actors[0]. Use the first actor's computer-use participants for a task protocol.`;
-        }
-        if (!supportsTasks) {
-            return "actors[0].tasks is unsupported on this execution path. Task protocols require the computer-use route, with one world per participant; shared-world, terminal-product, scripted-browser and synthetic routes do not consume them. Remove tasks only if a mission-only study is intended.";
-        }
+    if (actorOf(config)?.tasks !== undefined && !supportsTasks) {
+        return "actor.tasks is unsupported on this execution path. Task protocols require the computer-use route, with one world per participant; shared-world, terminal-product, scripted-browser and synthetic routes do not consume them. Remove tasks only if a mission-only study is intended.";
     }
     return null;
 }
@@ -228,35 +221,17 @@ export function cloneTargetValidationReason(config) {
     const got = target === undefined ? "it is absent" : `got "${target}"`;
     return `clone subjects require \`execution.target: e2b-desktop\` (${got}): humanish clones and serves the repo inside a hosted desktop sandbox. \`execution.target: local\` applies to app-url and local-app subjects.`;
 }
-/**
- * Refuse a positive `scenario.caps.maxUsd` or `maxTotalUsd` on a computer-use study.
- * `scenario.caps` belongs to the terminal route; the computer-use route stops on `execution.caps`,
- * so a dollar figure here would read as a cap while the study ran uncapped. Zero spends nothing
- * either way and stays a warning. Enforced at parse and again on the computer-use routes for
- * library callers.
- */
-export function scenarioCapsValidationReason(config) {
-    if (!isComputerUseComposition(config))
-        return null;
-    for (const key of ["maxUsd", "maxTotalUsd"]) {
-        const value = config.scenario?.caps?.[key];
-        if (value === undefined || value <= 0)
-            continue;
-        return `scenario.caps.${key} (${value}) does not cap a computer-use study: this route stops on execution.caps.${key}. Move the value to execution.caps.${key}; scenario.caps applies only to terminal-product studies.`;
-    }
-    return null;
-}
 /** Refuse a claimed output bound when the route cannot pass it to the first-party provider. */
 export function outputTokenLimitValidationReason(config) {
-    const actor = config.actors[0];
+    const actor = actorOf(config);
     if (actor?.maxOutputTokens === undefined)
         return null;
     if (!isMaxOutputTokens(actor.maxOutputTokens))
-        return "actors[0].maxOutputTokens must be a positive safe integer.";
+        return "actor.maxOutputTokens must be a positive safe integer.";
     if (actor.type !== "openai-computer-use" ||
         !isComputerUseComposition(config) ||
         config.subject.source === "local-app") {
-        return "actors[0].maxOutputTokens is supported only by first-party OpenAI computer-use routes; terminal, local-agent, scripted and custom in-process routes cannot enforce it.";
+        return "actor.maxOutputTokens is supported only by first-party OpenAI computer-use routes; terminal, local-agent, scripted and custom in-process routes cannot enforce it.";
     }
     return null;
 }
@@ -270,7 +245,7 @@ export function outputTokenLimitValidationReason(config) {
 function sharedWorldConcurrencyReason(config) {
     // Direct library callers skip the parser, so an omitted value defaults here exactly as the
     // route does: to the participant count. A missing roster reads as 0 and is refused.
-    const participants = rosterOf(config.actors[0])?.length ?? 0;
+    const participants = participantList(config)?.length ?? 0;
     const concurrency = config.execution?.concurrency ?? participants;
     if (concurrency >= 2)
         return null;
@@ -312,7 +287,7 @@ export function concurrentSharedWorldValidationReason(config) {
  * it rejects every provisioned-subject field (serve/state.seed/state.checkpoint/exposure/clone/repos
  * are inert with no sandbox, so they fail closed), and requires a
  * non-loopback appUrl + allowPublicTargets + the operator-ownership attestation subject.publicTarget +
- * concurrency >= 2 + an actors[0].lanes roster of ≥2 with exactly one host participant. The getHost synthetic
+ * concurrency >= 2 + a `participants` list of ≥2 with exactly one host participant. The getHost synthetic
  * gate is deliberately unreachable here (there is no internet-reachable harness-owned URL to attest).
  * Enforced at parse and re-enforced in the engine (runStudyWith takes a config that skipped the parser).
  */
@@ -327,12 +302,12 @@ export function externalPublicSharedWorldValidationReason(config) {
     if (config.execution?.target !== "e2b-desktop") {
         return "the external-public shared-world route requires `execution.target: e2b-desktop`: the role participants drive hosted desktop browsers against the one public deployment.";
     }
-    if (!actorResolvesToComputerUse(config.actors[0]?.type)) {
+    if (!actorResolvesToComputerUse(actorOf(config)?.type)) {
         return `the external-public shared-world route requires a registered computer-use actor (one of: ${registeredComputerUseActors().join(", ")}); each role participant runs a computer-use session.`;
     }
-    const roster = rosterOf(config.actors[0]);
+    const roster = participantList(config);
     if (!roster || roster.length < 2) {
-        return "the external-public shared-world route requires an `actors[0].lanes` roster of at least 2 roles (a single-participant shared world proves no shared session).";
+        return "the external-public shared-world route requires a `participants` list of at least 2 roles (a single-participant shared world proves no shared session).";
     }
     const sharedWorldConcurrency = sharedWorldConcurrencyReason(config);
     if (sharedWorldConcurrency)
@@ -367,7 +342,7 @@ export function externalPublicSharedWorldValidationReason(config) {
         return "`subject.clone` and `subject.repos` do not apply to an external-public shared-world study: the participants use the public deployment, so nothing is cloned. Remove them.";
     }
     if (roster.some((entry) => entry.entry !== undefined)) {
-        return "`actors[0].lanes[].entry` (the loopback same-origin participant path) is forbidden on the external-public shared-world route: there is no harness-served serve.url to resolve it against; participants open the public appUrl and reach the shared session through the real UI.";
+        return "`participants[].entry` (the loopback same-origin participant path) is forbidden on the external-public shared-world route: there is no harness-served serve.url to resolve it against; participants open the public appUrl and reach the shared session through the real UI.";
     }
     const hostEntries = roster.filter((entry) => entry.host === true);
     if (hostEntries.length !== 1) {

package/dist/study/warnings.d.ts

@@ -1,12 +1,12 @@
 import type { StudyConfig } from "./types.js";
 /**
- * The fields a config sets that its route does not read, each as `field` or `field (reason)`. A v2
- * file gets them as one warning; a v3 study is refused for any of them.
+ * The fields a config sets that its route does not read, each as `field` or `field (reason)`.
+ * parseStudy refuses a study for any of them.
  */
 export declare function inertFieldLabels(config: StudyConfig): string[];
 /**
  * The same fields as `inertFieldLabels`, as paths without their reasons, such as
- * `actors[0].lanes[].entry` or `execution.timeoutMs`. `humanish migrate` drops each one.
+ * `participants[].entry` or `execution.timeoutMs`. `humanish migrate` drops each one.
  */
 export declare function inertFieldPaths(config: StudyConfig): string[];
 export declare function forwardDeclaredWarnings(config: StudyConfig): string[];