@openwop/openwop-conformance 2.45.14 → 2.45.16

package/src/lib/dispatch-witness.ts

@@ -0,0 +1,212 @@
+/**
+ * The `core.dispatch` witnesses, fixture ports through `POST /runs` and
+ * `events/poll`. No seam.
+ *
+ * Input mapping (`spec/v2/facets/agents.schema.json` `dispatchMapping`;
+ * `schemas/v2/dispatch-config.schema.json` `inputMapping`), on
+ * `conformance-dispatch-input-mapping[-no-default]` →
+ * `conformance-dispatch-input-mapping-child`. A host advertising
+ * `agents.dispatchMapping: true` honors `inputMapping`, "building child inputs
+ * from parent variables before dispatch": the child receives
+ * `inputs[childKey] = parentVariables[parentKey]`.
+ *   projection  the child's `inputs.childGreeting` is the parent's
+ *               `parentName` ("Alice");
+ *   unset       an unset `parentName` projects to undefined — the child's
+ *               `inputs.childGreeting` is absent, never `null` or a placeholder.
+ *
+ * Supervisor loop (`execution.md` §`multiAgent`, level 1 and level 5), on
+ * `conformance-dispatch-loop`:
+ *   terminates  the run completes; each turn records a decision as
+ *               `runOrchestrator.decided` (`orchestrator.decided` at major 2),
+ *               and the last is `terminate` — `terminate` completes the run,
+ *               so no decision follows it;
+ *   decisions   every decision payload is well-formed (the decision checked
+ *               branch by branch — see {@link decisionBranchValidator}), and
+ *               its `agentId` is the same for the run's lifetime;
+ *   iteration   at `executionModel.version >= 5`, every decision carries
+ *               `iteration`, 1-based, incremented by exactly 1 per turn.
+ *
+ * The drivers observe and assert nothing; the judges are pure, proven in
+ * `dispatch-witness.test.ts`.
+ */
+
+import { isFixtureAdvertised } from './fixtures.js';
+import type { MajorProfile } from './major-profile.js';
+import {
+  completionsOf, finding, isRecord, observed, observeRun, readRun, runCompleted, skip,
+  type Ev, type Finding, type ObservedRun, type ObserveOpts, type Outcome, type RunRead, type Skip, type Validate,
+} from './fixture-run-observer.js';
+
+export const DISPATCH_PARENT_FIXTURE = 'conformance-dispatch-input-mapping';
+export const DISPATCH_NO_DEFAULT_FIXTURE = 'conformance-dispatch-input-mapping-no-default';
+export const DISPATCH_CHILD_FIXTURE = 'conformance-dispatch-input-mapping-child';
+export const DISPATCH_NODE = 'dispatch';
+export const LOOP_FIXTURE = 'conformance-dispatch-loop';
+
+const DOC_MAP = 'agents.schema.json dispatchMapping; dispatch-config.schema.json inputMapping';
+const DOC_LOOP = 'execution.md §multiAgent';
+
+export interface DispatchObservation {
+  readonly parent: ObservedRun;
+  /** How the child was found: the parent's `node.dispatched`, or the dispatch node's `node.completed` outputs. */
+  readonly childRunId: string | undefined;
+  readonly child: RunRead | undefined;
+}
+
+/** `agents.dispatchMapping: true`, the parent fixture and the child fixture. */
+export function dispatchMappingGate(profile: MajorProfile, doc: unknown, fixture: string): Skip | null {
+  const agents = profile.family(doc, 'agents');
+  if (agents === null) return skip('inapplicable', 'the host does not advertise agents');
+  if (agents['dispatchMapping'] !== true) return skip('inapplicable', 'the host does not advertise agents.dispatchMapping: true, so inputMapping does not bind it (it must refuse the field at registration instead)');
+  for (const id of [fixture, DISPATCH_CHILD_FIXTURE]) if (!isFixtureAdvertised(id)) return skip('inapplicable', `fixture ${id} is not advertised — the fixture is the opt-in`);
+  return null;
+}
+
+/** Find the dispatched child: `node.dispatched` naming the child workflow, else the dispatch node's outputs. */
+export function locateChild(profile: MajorProfile, events: readonly Ev[], childWorkflowId: string): string | undefined {
+  const dispatchedType = profile.eventType('node.dispatched') ?? 'node.dispatched';
+  const d = events.find((e) => e.type === dispatchedType && e.payload['childWorkflowId'] === childWorkflowId && typeof e.payload['childRunId'] === 'string');
+  if (d !== undefined) return d.payload['childRunId'] as string;
+  for (const c of completionsOf(events, DISPATCH_NODE)) {
+    const out = c.payload['outputs'];
+    if (isRecord(out) && typeof out['childRunId'] === 'string' && out['childRunId'].length > 0) return out['childRunId'];
+  }
+  return undefined;
+}
+
+/** Run a dispatch input-mapping fixture and follow it to the child. Asserts nothing. */
+export async function driveDispatchMapping(profile: MajorProfile, doc: unknown, fixture: string, opts: ObserveOpts = {}): Promise<Skip | DispatchObservation> {
+  const g = dispatchMappingGate(profile, doc, fixture);
+  if (g) return g;
+  const parent = await observeRun(profile, fixture, opts);
+  const childRunId = locateChild(profile, parent.events, DISPATCH_CHILD_FIXTURE);
+  return { parent, childRunId, child: childRunId === undefined ? undefined : await readRun(profile, childRunId) };
+}
+
+function childInputs(o: DispatchObservation): Skip | { inputs: Record<string, unknown>; reached: Finding[] } {
+  if (o.parent.createStatus !== 201 && o.parent.createStatus !== 202) return { inputs: {}, reached: runCompleted(o.parent) };
+  if (o.childRunId === undefined) return skip('inapplicable', `no v2 rule requires a host to expose the dispatched child, and this one does not: the parent log names no ${DISPATCH_CHILD_FIXTURE} run (no node.dispatched, no dispatch-node outputs.childRunId), so its inputs cannot be read`);
+  const c = o.child;
+  return {
+    inputs: c !== undefined && isRecord(c.snapshot['inputs']) ? c.snapshot['inputs'] : {},
+    reached: [
+      ...runCompleted(o.parent),
+      finding(c?.status === 200, 'runs.md getRun', `the dispatched child run MUST be readable (GET answered ${String(c?.status)})`),
+      finding(c?.snapshot['status'] === 'completed', `fixtures.md ${DISPATCH_CHILD_FIXTURE}`, `the child run MUST end completed (got ${JSON.stringify(c?.snapshot['status'])})`),
+    ],
+  };
+}
+
+/** Leg: the child's inputs carry the parent's projected variable. Pure. */
+export function judgeProjection(o: DispatchObservation): Outcome {
+  const c = childInputs(o);
+  if ('kind' in c) return c;
+  return observed([
+    ...c.reached,
+    finding(c.inputs['childGreeting'] === 'Alice', DOC_MAP, `the child MUST receive inputs.childGreeting = parentVariables.parentName ("Alice"; got ${JSON.stringify(c.inputs['childGreeting'])})`),
+  ]);
+}
+
+/** Leg: an unset parent variable projects to undefined — absent, never null. Pure. */
+export function judgeUnsetProjection(o: DispatchObservation): Outcome {
+  const c = childInputs(o);
+  if ('kind' in c) return c;
+  return observed([
+    ...c.reached,
+    finding(c.inputs['childGreeting'] !== null, `${DOC_MAP} (mirrors execution.md §subWorkflow inputMapping: never null)`, 'an unset parent variable MUST NOT project as null'),
+    finding(!('childGreeting' in c.inputs), DOC_MAP, `inputs[childKey] = parentVariables[parentKey] is undefined for an unset parent variable: inputs.childGreeting MUST be absent (got ${JSON.stringify(c.inputs['childGreeting'])})`),
+  ]);
+}
+
+export interface LoopObservation { readonly run: ObservedRun; readonly decidedType: string; readonly version: number }
+
+/** `multiAgent.executionModel.version >= 1`, the fixture, and this major's event name. */
+export function loopGate(profile: MajorProfile, doc: unknown): Skip | { decidedType: string; version: number } {
+  const ma = profile.family(doc, 'multiAgent');
+  const em = isRecord(ma?.['executionModel']) ? ma['executionModel'] : undefined;
+  const version = em?.['version'];
+  if (typeof version !== 'number' || version < 1) return skip('inapplicable', 'the host does not advertise multiAgent.executionModel (version >= 1), so the supervisor loop does not bind it');
+  if (!isFixtureAdvertised(LOOP_FIXTURE)) return skip('inapplicable', `fixture ${LOOP_FIXTURE} is not advertised — the fixture is the opt-in`);
+  const decidedType = profile.eventType('runOrchestrator.decided');
+  if (decidedType === undefined) return skip('blocked', 'the event codemap is not on disk in this layout — the suite will not guess an event name');
+  return { decidedType, version };
+}
+
+/** Run the loop fixture. Asserts nothing. */
+export async function driveLoop(profile: MajorProfile, doc: unknown, opts: ObserveOpts = {}): Promise<Skip | LoopObservation> {
+  const g = loopGate(profile, doc);
+  if ('kind' in g) return g;
+  return { run: await observeRun(profile, LOOP_FIXTURE, opts), ...g };
+}
+
+const decisions = (o: LoopObservation): Ev[] => o.run.events.filter((e) => e.type === o.decidedType);
+const kindOf = (e: Ev): unknown => (isRecord(e.payload['decision']) ? e.payload['decision']['kind'] : undefined);
+
+/** Leg: decisions are recorded, the last is `terminate`, and it completes the run. Pure. */
+export function judgeLoopTerminates(o: LoopObservation): Outcome {
+  const ds = decisions(o);
+  const firstTerminate = ds.findIndex((e) => kindOf(e) === 'terminate');
+  return observed([
+    ...runCompleted(o.run),
+    finding(ds.length > 0, `${DOC_LOOP} (level 1)`, `each turn MUST record its decision as ${o.decidedType} (got none)`),
+    finding(ds.length > 0 && kindOf(ds[ds.length - 1]!) === 'terminate', `${DOC_LOOP} (level 1: terminate completes the run)`, `the completed loop's last decision MUST be terminate (got ${JSON.stringify(ds.map(kindOf))})`),
+    finding(firstTerminate === -1 || firstTerminate === ds.length - 1, `${DOC_LOOP} (level 1: terminate completes the run)`, `no decision may follow a terminate (got ${JSON.stringify(ds.map(kindOf))})`),
+  ]);
+}
+
+/**
+ * A validator for one `OrchestratorDecision`, by its `oneOf` branches.
+ *
+ * `schemas/v2/orchestrator-decision.schema.json` closes its ROOT with
+ * `additionalProperties: false` and declares no root `properties`, so the
+ * schema as a whole rejects every decision, `kind` included (the v1 root is
+ * open). Validating against it would convict every host. Until the corpus
+ * fixes it, a decision is valid when exactly one branch accepts it.
+ */
+export function decisionBranchValidator(branch: (index: number) => Validate, branches = 3): Validate {
+  const vs = Array.from({ length: branches }, (_, i) => branch(i));
+  return (doc) => {
+    const results = vs.map((v) => v(doc));
+    const ok = results.filter((r) => r.ok).length === 1;
+    return { ok, errors: ok ? '' : results.map((r, i) => `branch ${i}: ${r.errors || 'accepted'}`).join(' | ') };
+  };
+}
+
+const PAYLOAD_KEYS = new Set(['agentId', 'decision', 'iteration', 'causationHostId']);
+const AGENT_ID = /^[A-Za-z0-9._~:-]{1,128}$/;
+
+/**
+ * Leg: every decision payload is well-formed (the `runOrchestratorDecided`
+ * def's closed key set and `agentId`; the decision by its branches), and the
+ * deciding agent never changes. Pure.
+ */
+export function judgeDecisions(o: LoopObservation, validateDecision: Validate): Outcome {
+  const ds = decisions(o);
+  if (ds.length === 0) return skip('inapplicable', `the loop recorded no ${o.decidedType}, so there is nothing to judge here — the terminates leg convicts that`);
+  const agents = new Set(ds.map((e) => e.payload['agentId']));
+  const DEF = 'schemas run-event-payloads runOrchestratorDecided';
+  return observed([
+    ...ds.flatMap((e) => {
+      const extra = Object.keys(e.payload).filter((k) => !PAYLOAD_KEYS.has(k));
+      const agentId = e.payload['agentId'];
+      const v = validateDecision(e.payload['decision']);
+      return [
+        finding(extra.length === 0, DEF, `a ${o.decidedType} payload carries only agentId, decision, iteration, causationHostId (seq ${e.sequence}; extra ${JSON.stringify(extra)})`),
+        finding(typeof agentId === 'string' && AGENT_ID.test(agentId), `${DEF}.agentId`, `every ${o.decidedType} MUST carry agentId (seq ${e.sequence}; got ${JSON.stringify(agentId)})`),
+        finding(v.ok, 'schemas orchestrator-decision', `every decision MUST be one OrchestratorDecision (seq ${e.sequence}): ${v.errors}`),
+      ];
+    }),
+    finding(agents.size === 1, `${DEF}.agentId`, `orchestrator identity is set at the first decision and does not change (got ${JSON.stringify([...agents])})`),
+  ]);
+}
+
+/** Leg: at version >= 5, `iteration` is 1-based and +1 per turn. Pure. */
+export function judgeIteration(o: LoopObservation): Outcome {
+  if (o.version < 5) return skip('inapplicable', `the host advertises multiAgent.executionModel.version ${o.version}; iteration binds from level 5`);
+  const ds = decisions(o);
+  if (ds.length === 0) return skip('inapplicable', `the loop recorded no ${o.decidedType}, so there is nothing to judge here — the terminates leg convicts that`);
+  const its = ds.map((e) => e.payload['iteration']);
+  return observed([
+    finding(its.every((n, i) => n === i + 1), `${DOC_LOOP} (level 5)`, `every ${o.decidedType} MUST carry iteration, 1-based and incremented by exactly 1 per turn (got ${JSON.stringify(its)})`),
+  ]);
+}

package/src/lib/envelope-schema-static.ts

@@ -0,0 +1,166 @@
+/**
+ * Static walkers over envelope payload schemas, shared by the v2 static twins
+ * `v2-envelope-tier-one-subset-static` and `v2-envelope-variant-discriminator-static`.
+ *
+ * The walk rules are the v1 rules unchanged (RFC 0030 §B, RFC 0031 §A); what
+ * moved at major 2 is where the schemas live (`schemas/v2/envelopes/`) and
+ * where a host's kind catalog is advertised (`supportedEnvelopes.kinds`, a
+ * family record, instead of a root `string[]`).
+ *
+ * Every function here is pure and is proven in both directions in
+ * `envelope-schema-static.test.ts`: a conforming schema yields no violation,
+ * and each defect yields the one it names.
+ */
+
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { SCHEMAS_DIR } from './paths.js';
+
+export interface SchemaViolation { readonly path: string; readonly rule: string; readonly detail?: string }
+
+const isRecord = (v: unknown): v is Record<string, unknown> => v !== null && typeof v === 'object' && !Array.isArray(v);
+
+/** The v2 envelope payload schema directory. */
+export const V2_ENVELOPES_DIR = join(SCHEMAS_DIR, 'v2', 'envelopes');
+
+/** The four kinds every engine recognizes (`events.md` §"AI envelopes"). */
+export const UNIVERSAL_KINDS = ['clarification.request', 'schema.request', 'schema.response', 'error'] as const;
+
+/** A v2 envelope payload schema by kind, or `null` when the corpus has none. */
+export function loadV2EnvelopeSchema(kind: string): Record<string, unknown> | null {
+  const p = join(V2_ENVELOPES_DIR, `${kind}.schema.json`);
+  if (!existsSync(p)) return null;
+  const v: unknown = JSON.parse(readFileSync(p, 'utf8'));
+  return isRecord(v) ? v : null;
+}
+
+/** Every kind with a payload schema under `schemas/v2/envelopes/`. */
+export function listV2EnvelopeKinds(): string[] {
+  if (!existsSync(V2_ENVELOPES_DIR)) return [];
+  return readdirSync(V2_ENVELOPES_DIR).filter((f) => f.endsWith('.schema.json')).map((f) => f.replace(/\.schema\.json$/, '')).sort();
+}
+
+// ---------------------------------------------------------------------------
+// RFC 0030 §B — the Tier-1 structured-output subset.
+// ---------------------------------------------------------------------------
+
+/** Keywords that fail across more than one Tier-1 vendor (Gemini drops `oneOf` silently). Checked in both modes. */
+const LOAD_BEARING_KEYWORDS = ['oneOf', 'allOf', 'not', 'if', 'then', 'else', 'dependencies', 'prefixItems', 'propertyNames'] as const;
+export const MAX_DEPTH = 5;
+export const MAX_PROPERTIES = 100;
+
+const hasType = (schema: Record<string, unknown>, t: string): boolean => schema['type'] === t || (Array.isArray(schema['type']) && (schema['type'] as unknown[]).includes(t));
+
+/**
+ * Walk a payload schema for Tier-1 subset violations.
+ *
+ * `load-bearing`: only the rules that fail across several vendors — the floor
+ * every corpus schema is held to. `strict`: every rule of the OpenAI-strict ∩
+ * Anthropic-strict ∩ Gemini intersection, applied only when a host advertises
+ * `envelopes.tierOneSubsetCompliance: "strict"`.
+ */
+export function tierOneViolations(schema: Record<string, unknown>, mode: 'load-bearing' | 'strict'): SchemaViolation[] {
+  const out: SchemaViolation[] = [];
+  const count = { n: 0 };
+  walkTierOne(schema, '#', 0, count, out, mode);
+  if (count.n > MAX_PROPERTIES) out.push({ path: '#', rule: 'max-property-count-100-exceeded', detail: `count=${count.n}` });
+  return out;
+}
+
+function walkTierOne(schema: Record<string, unknown>, path: string, depth: number, count: { n: number }, out: SchemaViolation[], mode: 'load-bearing' | 'strict'): void {
+  if (depth > MAX_DEPTH) { out.push({ path, rule: 'max-nesting-depth-5', detail: `depth=${depth}` }); return; }
+  for (const kw of LOAD_BEARING_KEYWORDS) if (kw in schema) out.push({ path, rule: 'forbidden-keyword', detail: kw });
+  if (Array.isArray(schema['anyOf'])) {
+    (schema['anyOf'] as unknown[]).forEach((b, i) => { if (isRecord(b)) walkTierOne(b, `${path}/anyOf/${i}`, depth + 1, count, out, mode); });
+  }
+  if (hasType(schema, 'object')) {
+    if (mode === 'strict' && schema['additionalProperties'] !== false) out.push({ path, rule: 'additionalProperties-must-be-false-on-object-strict-only' });
+    const props = isRecord(schema['properties']) ? schema['properties'] : {};
+    const required = Array.isArray(schema['required']) ? (schema['required'] as unknown[]) : [];
+    for (const [name, sub] of Object.entries(props)) {
+      count.n++;
+      if (mode === 'strict' && !required.includes(name)) out.push({ path: `${path}/properties/${name}`, rule: 'property-not-in-required-strict-mode-only' });
+      if (isRecord(sub)) walkTierOne(sub, `${path}/properties/${name}`, depth + 1, count, out, mode);
+    }
+  }
+  if (mode === 'strict') {
+    const bounded: Array<[boolean, readonly string[], string]> = [
+      [hasType(schema, 'string'), ['minLength', 'maxLength', 'pattern', 'format'], 'forbidden-string-constraint-strict-only'],
+      [hasType(schema, 'number') || hasType(schema, 'integer'), ['minimum', 'maximum', 'multipleOf'], 'forbidden-number-constraint-strict-only'],
+      [hasType(schema, 'array'), ['minItems', 'maxItems', 'uniqueItems'], 'forbidden-array-constraint-strict-only'],
+    ];
+    for (const [applies, kws, rule] of bounded) if (applies) for (const kw of kws) if (kw in schema) out.push({ path, rule, detail: kw });
+  }
+  if (hasType(schema, 'array') && isRecord(schema['items'])) walkTierOne(schema['items'], `${path}/items`, depth + 1, count, out, mode);
+  const defs = isRecord(schema['$defs']) ? schema['$defs'] : {};
+  for (const [name, sub] of Object.entries(defs)) if (isRecord(sub)) walkTierOne(sub, `${path}/$defs/${name}`, depth + 1, count, out, mode);
+}
+
+// ---------------------------------------------------------------------------
+// RFC 0031 §A — variant payloads: no `oneOf`; every `anyOf` branch discriminated.
+// ---------------------------------------------------------------------------
+
+/** `oneOf` anywhere in a payload schema. */
+export function oneOfViolations(schema: unknown, path = '#'): SchemaViolation[] {
+  const out: SchemaViolation[] = [];
+  const walk = (s: unknown, p: string): void => {
+    if (Array.isArray(s)) { s.forEach((x, i) => walk(x, `${p}/${i}`)); return; }
+    if (!isRecord(s)) return;
+    if ('oneOf' in s) out.push({ path: p, rule: 'oneOf-forbidden', detail: 'use anyOf with a single-string-enum discriminator (RFC 0031 §A)' });
+    for (const [k, v] of Object.entries(s)) walk(v, `${p}/${k}`);
+  };
+  walk(schema, path);
+  return out;
+}
+
+/**
+ * A branch is discriminated when one of its `required` properties is
+ * `type: string` with an `enum` of exactly one value. A `$ref` branch is
+ * accepted unresolved, as at v1: the referenced shape is walked where it is
+ * defined, and a version-selected union (one branch per `schemaVersion`, as
+ * `ui.a2ui-surface` declares) is not a payload-field discrimination at all.
+ */
+export function branchDiscriminated(branch: unknown): boolean {
+  if (!isRecord(branch)) return false;
+  if ('$ref' in branch) return true;
+  const required = Array.isArray(branch['required']) ? (branch['required'] as unknown[]) : [];
+  const props = isRecord(branch['properties']) ? branch['properties'] : {};
+  return required.some((name) => {
+    const p = typeof name === 'string' ? props[name] : undefined;
+    return isRecord(p) && p['type'] === 'string' && Array.isArray(p['enum']) && (p['enum'] as unknown[]).length === 1;
+  });
+}
+
+/** Whether a branch can match a JSON object: an explicit object type, a `$ref`, or object keywords with no type. */
+function admitsObject(branch: unknown): boolean {
+  if (!isRecord(branch)) return false;
+  if ('$ref' in branch) return true;
+  const t = branch['type'];
+  if (t === undefined) return 'properties' in branch || 'required' in branch;
+  return t === 'object' || (Array.isArray(t) && t.includes('object'));
+}
+
+/**
+ * Every `anyOf` branch, at any depth, that carries no single-string-enum
+ * discriminator — in a VARIANT union, one where two or more branches can be
+ * objects. A union with at most one object branch (`string | binding`,
+ * `string | number | boolean | array | binding`, as `ui.a2ui-surface`
+ * payload v2 declares) is a type union: JSON type alone selects the branch, no
+ * field is inspected, and a scalar branch has no property to discriminate on.
+ * RFC 0031 §A governs variant payloads; it is not read as forbidding these.
+ */
+export function anyOfDiscriminatorViolations(schema: unknown, path = '#'): SchemaViolation[] {
+  const out: SchemaViolation[] = [];
+  const walk = (s: unknown, p: string): void => {
+    if (Array.isArray(s)) { s.forEach((x, i) => walk(x, `${p}/${i}`)); return; }
+    if (!isRecord(s)) return;
+    if (Array.isArray(s['anyOf']) && (s['anyOf'] as unknown[]).filter(admitsObject).length >= 2) {
+      (s['anyOf'] as unknown[]).forEach((b, i) => {
+        if (admitsObject(b) && !branchDiscriminated(b)) out.push({ path: `${p}/anyOf/${i}`, rule: 'anyOf-branch-missing-discriminator', detail: 'a branch MUST declare a single-string-enum discriminator property in required (RFC 0031 §A)' });
+      });
+    }
+    for (const [k, v] of Object.entries(s)) walk(v, `${p}/${k}`);
+  };
+  walk(schema, path);
+  return out;
+}

package/src/lib/exhaustion-facet-witness.ts

@@ -75,7 +75,7 @@ export async function drive(profile: MajorProfile, doc: unknown): Promise<FacetR
 
   // A host that accepted the create started a run. Stop it, so a failing row leaves none behind.
   const runId = (res.json as { runId?: unknown } | undefined)?.runId;
-  if (typeof runId === 'string') await http(() => driver.post(`${profile.runsPath}/${encodeURIComponent(runId)}/cancel`, {}));
+  if (typeof runId === 'string') await http(() => driver.post(`${profile.runsPath}/${profile.idSegment(runId)}/cancel`, {}));
 
   return { kind: 'observed', observation: { facet, create: { status: res.status, code: readErrorCode(res.json) ?? undefined } } };
 }