@volter/twin-standard 1.0.90 → 1.0.92

package/README.md

@@ -14,7 +14,8 @@ twin-standard grade <pack or lane dir>… [--static] [--form]  # each criterion'
 twin-standard derive <pack or lane dir> [--out <dir>]        # write src/generated/ from the vendored spec
 twin-standard check-sources <pack or lane dir> [--recheck]   # fetch and record the sources the unit cites
 twin-standard facts <pack dir> [--out <file>]               # package-local facts from its descriptor
-twin-standard assess <pack dir> [--browser] [--out <file>]   # inside a World
+twin-standard prepare-consumer <pack dir> --app <new dir> --cli <volter executable> --integrity <sha512> --out <json>
+twin-standard assess <pack dir> --prepared-consumer <json> [--browser] [--out <file>]  # inside a World
 twin-standard --version                                      # this package's version and each standard's
 ```
 
@@ -23,7 +24,16 @@ What each criterion asks, and the rules for changing one, are twin-world's
 A changed criterion is a release of this package: a criterion's id never changes meaning; a changed criterion takes a
 new id and a new standard version, and a tightened check names what newly fails.
 
-The public `assessPack(packDir, { browser: true })` API runs inside a World, reports actual operation coverage from
+The public `assessPack(packDir, { browser: true, consumer })` API runs inside a World, reports actual operation coverage from
 kernel dispatch and replays journeys through Chromium when their wire is HTTP. Install Playwright and Chromium for
 that target. Its report distinguishes API support, operations exercised, journey failures and replay, and does not
-claim DOM interaction coverage. Catalog controllers own provenance, admission and publication.
+claim DOM interaction coverage. `consumer` contains absolute `appDir` and `cli` paths and the candidate's
+`artifactIntegrity`. Prepare the pack's `journeys/first-use.json` with `prepareConsumerApp(packDir, newAppDir)`,
+then install its exact SDK dependencies with scripts disabled before the assessment World starts. The public
+`runConsumerWorkflow(packDir, consumer)` lets a builder walk only that entry journey while authoring; it runs no
+grade or conformance checks. Installed readiness requires ordinary CLI initialization against the exact candidate,
+SDK assertions, read-only state inspection after stop/resume for stored workflows, and verified teardown. A
+stateless workflow records why retained-state inspection does not apply. Empty SDK case execution fails.
+
+The [canonical pack procedure](https://github.com/volter-ai/twin-world/blob/main/docs/contributing/architecture.md#creating-a-pack)
+owns the recipe format and completion requirements. Catalog controllers own provenance, admission and publication.

package/dist/src/assessment.d.ts

@@ -1,6 +1,8 @@
+import { type ConsumerOptions } from './consumer.js';
 export type AssessmentOptions = {
     browser?: boolean;
     conformance?: boolean;
+    consumer?: ConsumerOptions;
 };
 /** Surface coverage counts actual kernel dispatch, and retains every declared gap in the denominator. */
 export declare function assessPack(packDir: string, options?: AssessmentOptions): Promise<{
@@ -46,4 +48,45 @@ export declare function assessPack(packDir: string, options?: AssessmentOptions)
     };
     browser: Record<string, unknown>;
     conformance: import("./conformance.js").ConformanceResult[] | null;
+    consumer: {
+        node: string;
+        at: string;
+        retentionNotApplicable?: string | undefined;
+        measured: boolean;
+        passed: boolean;
+        scope: string;
+        package: any;
+        version: any;
+        integrity: string;
+        tools: {
+            '@volter/world': string;
+            '@volter/world-core': string;
+            '@volter/world-runtime': string;
+        };
+        sourceInputsSha256: string;
+        recipeSha256: string;
+        fixture: string;
+        appDir: string;
+        appName: string;
+        commands: {
+            label: string;
+            argv: string[];
+            exitCode: number | null;
+            stdout: string;
+            stderr: string;
+        }[];
+        failures: string[];
+        teardownVerified: boolean;
+        retainedReadback: boolean;
+        clock: {
+            at: string;
+            advanceAfterRun?: string;
+        } | {
+            mode: string;
+        };
+    } | {
+        measured: boolean;
+        passed: boolean;
+        failures: string[];
+    };
 }>;

package/dist/src/assessment.js

@@ -16,6 +16,7 @@ import { conformance } from "./conformance.js";
 import { inMemoryWorld, walk, withPinnedWorldDraws, usePacks } from "./walk/behavior-journey.js";
 import { compilePackFacts } from "./pack-facts.js";
 import { expandFills } from "./walk/journey-kit.js";
+import { runConsumerWorkflow } from "./consumer.js";
 const canonical = (value) => value && typeof value === 'object' ? Array.isArray(value) ? value.map(canonical) : Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => [key, canonical(item)])) : value;
 const json = (value) => JSON.stringify(canonical(value));
 const hash = (value) => createHash('sha256').update(json(value)).digest('hex');
@@ -119,6 +120,13 @@ export async function assessPack(packDir, options = {}) {
         }
     }
     const conform = options.conformance === false ? null : await conformance(packDir);
-    const ready = gates.length > 0 && gates.every((gate) => !gate.failures.length) && !quick.failures.length && replayEqual && conform !== null && conform.length > 0 && conform.every((result) => !result.failures.length) && (!options.browser || !httpOnly || browser.measured === true && browser.failures.length === 0 && browser.replay.equal);
-    return { schemaVersion: 1, vendor, package: manifest.name, version: manifest.version, ready, gates: gates.map((gate) => ({ ...gate, unit: gate.unit === packDir ? vendor : `${vendor}/${gate.unit.slice(packDir.length + 1)}` })), quick, browser, conformance: conform };
+    let consumer;
+    try {
+        consumer = options.consumer ? await runConsumerWorkflow(packDir, options.consumer) : { measured: false, passed: false, failures: ['Installed customer workflow was not prepared'] };
+    }
+    catch (error) {
+        consumer = { measured: false, passed: false, failures: [error.message] };
+    }
+    const ready = gates.length > 0 && gates.every((gate) => !gate.failures.length) && !quick.failures.length && replayEqual && conform !== null && conform.length > 0 && conform.every((result) => !result.failures.length) && consumer.measured && consumer.passed && (!options.browser || !httpOnly || browser.measured === true && browser.failures.length === 0 && browser.replay.equal);
+    return { schemaVersion: 1, vendor, package: manifest.name, version: manifest.version, ready, gates: gates.map((gate) => ({ ...gate, unit: gate.unit === packDir ? vendor : `${vendor}/${gate.unit.slice(packDir.length + 1)}` })), quick, browser, conformance: conform, consumer };
 }

package/dist/src/cli.js

@@ -31,7 +31,7 @@ import { standardPackageFile } from "./package-file.js";
 import { gatePublished } from "./published.js";
 const [command, ...args] = process.argv.slice(2);
 const usage = () => {
-    console.error('usage: twin-standard gate <repo> [units…] | gate-published <name>@<version>… [--registry <url>] | grade <unit>… [--static] [--form] | derive <unit> [--out <dir>] | read-page <url> [--raw] | check-sources <unit> [--recheck] | conform <pack dir> | <name>@<version> [--registry <url>] | create <dir> --init <vendor> --package <@scope/name> | create <unit> --index | facts <pack dir> [--out <file>] | assess <pack dir> [--browser] [--out <file>] | --version');
+    console.error('usage: twin-standard gate <repo> [units…] | gate-published <name>@<version>… [--registry <url>] | grade <unit>… [--static] [--form] | derive <unit> [--out <dir>] | read-page <url> [--raw] | check-sources <unit> [--recheck] | conform <pack dir> | <name>@<version> [--registry <url>] | create <dir> --init <vendor> --package <@scope/name> | create <unit> --index | facts <pack dir> [--out <file>] | prepare-consumer <pack dir> --app <new dir> --cli <volter executable> --integrity <sha512> --out <json> | assess <pack dir> --prepared-consumer <json> [--browser] [--out <file>] | --version');
     process.exit(2);
 };
 if (command === '--version') {
@@ -109,11 +109,34 @@ else if (command === 'create') {
         throw new Error('Name your scoped package with --package');
     await (await import("./create-pack.js")).createPack(args);
 }
+else if (command === 'prepare-consumer') {
+    if (!args[0])
+        usage();
+    const value = (name) => { const at = args.indexOf(name); if (at < 0 || !args[at + 1])
+        usage(); return args[at + 1]; };
+    const appDir = resolve(value('--app'));
+    const cli = resolve(value('--cli'));
+    const artifactIntegrity = value('--integrity');
+    if (!/^sha512-[A-Za-z0-9+/]{86}==$/.test(artifactIntegrity))
+        throw new Error('Consumer preparation requires candidate SHA-512 integrity');
+    const out = resolve(value('--out'));
+    if (existsSync(out))
+        throw new Error('Prepared consumer output already exists');
+    const { prepareConsumerApp } = await import("./consumer.js");
+    const fixture = prepareConsumerApp(resolve(args[0]), appDir);
+    const { writeFileSync } = await import('node:fs');
+    writeFileSync(out, JSON.stringify({ appDir, cli, artifactIntegrity }, null, 2) + '\n');
+    console.log(JSON.stringify({ appDir, fixture, preparedConsumer: out, next: 'Install the app SDK dependencies with scripts disabled before assessing inside a World' }));
+}
 else if (command === 'assess') {
     if (!args[0])
         usage();
     const { assessPack } = await import("./assessment.js");
-    const report = await assessPack(resolve(args[0]), { browser: args.includes('--browser') });
+    const consumerAt = args.indexOf('--prepared-consumer');
+    if (consumerAt >= 0 && !args[consumerAt + 1])
+        usage();
+    const consumer = consumerAt >= 0 ? JSON.parse(readFileSync(resolve(args[consumerAt + 1]), 'utf8')) : undefined;
+    const report = await assessPack(resolve(args[0]), { browser: args.includes('--browser'), ...(consumer ? { consumer } : {}) });
     const at = args.indexOf('--out');
     if (at >= 0) {
         if (!args[at + 1])

package/dist/src/clients/anthropic.first-use.json

@@ -0,0 +1,17 @@
+{
+  "schemaVersion": 1,
+  "source": "https://www.npmjs.com/package/@anthropic-ai/sdk/v/0.131.0",
+  "about": "Use the official SDK for Messages and streaming, checking the explicitly labeled model stub.",
+  "files": {
+    "package.json": "{\n  \"name\": \"anthropic-installed-customer\",\n  \"private\": true,\n  \"type\": \"module\",\n  \"dependencies\": {\n    \"@anthropic-ai/sdk\": \"0.131.0\"\n  }\n}\n",
+    ".env.example": "ANTHROPIC_API_KEY=\n",
+    "app.mjs": "import Anthropic from '@anthropic-ai/sdk';\nimport assert from 'node:assert/strict';\nimport { writeFileSync } from 'node:fs';\nassert.ok(process.env.VOLTER_WORLD, 'must run in the World');\nconst client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY, maxRetries:0 });\nconst input = {model:'claude-sonnet-4-5', max_tokens:128, messages:[{role:'user',content:'first-user deterministic fixture'}]};\nconst response = await client.messages.create(input);\nconst text = response.content.filter(x=>x.type==='text').map(x=>x.text).join('');\nassert.match(text,/\\[twin-stub:/);\nassert.equal(response.role,'assistant');\nassert.equal(response.stop_reason,'end_turn');\nlet streamed='';\nfor await (const event of await client.messages.create({...input,stream:true})) if (event.type==='content_block_delta' && event.delta.type==='text_delta') streamed+=event.delta.text;\nassert.equal(streamed,text);\nconst receipt={passed:true,scope:'unchanged official Anthropic SDK non-streamed and streamed Messages; labeled deterministic stub, no prose quality claim',};\nwriteFileSync('first-use-receipt.json',JSON.stringify(receipt,null,2)+'\\n');console.log(JSON.stringify(receipt));\n"
+  },
+  "run": [
+    "node",
+    "app.mjs"
+  ],
+  "retention": {
+    "none": "This workflow requests an unstored message and stream; it creates no vendor resource to read after restart."
+  }
+}

package/dist/src/clients/clerk.first-use.json

@@ -0,0 +1,21 @@
+{
+  "schemaVersion": 1,
+  "source": "https://www.npmjs.com/package/@clerk/backend/v/2.33.3",
+  "about": "A first user creates a user and organization, adds a member, verifies a signed session token and removes the member; after resume the original owner and membership remain.",
+  "files": {
+    "package.json": "{\n  \"name\": \"clerk-installed-customer\",\n  \"private\": true,\n  \"type\": \"module\",\n  \"dependencies\": {\n    \"@clerk/backend\": \"2.33.3\"\n  }\n}\n",
+    ".env.example": "CLERK_SECRET_KEY=\nCLERK_PUBLISHABLE_KEY=\nCLERK_JWT_KEY=\n",
+    "workflow.mjs": "import assert from 'node:assert/strict';\nimport { writeFileSync } from 'node:fs';\nimport { createClerkClient, verifyToken } from '@clerk/backend';\n\nassert.ok(process.env.VOLTER_WORLD);\nconst clerk = createClerkClient({ secretKey: process.env.CLERK_SECRET_KEY });\nawait clerk.instance.updateOrganizationSettings({ enabled: true });\nconst owner = await clerk.users.createUser({ emailAddress: ['owner@catalog-clerk.example'], firstName: 'First', skipPasswordRequirement: true });\nconst org = await clerk.organizations.createOrganization({ name: 'Catalog first user', createdBy: owner.id });\nconst guest = await clerk.users.createUser({ emailAddress: ['member@catalog-clerk.example'], firstName: 'Member', skipPasswordRequirement: true });\nawait clerk.organizations.createOrganizationMembership({ organizationId: org.id, userId: guest.id, role: 'org:member' });\nconst before = await clerk.organizations.getOrganizationMembershipList({ organizationId: org.id, limit: 100 });\nassert.equal(before.totalCount, 2);\nassert.ok(before.data.some(member => member.publicUserData.userId === guest.id));\nconst session = await clerk.sessions.createSession({ userId: guest.id });\nconst { jwt } = await clerk.sessions.getToken(session.id);\nconst payload = await verifyToken(jwt, { secretKey: process.env.CLERK_SECRET_KEY });\nassert.equal(payload.sub, guest.id);\nassert.equal(payload.sid, session.id);\nawait clerk.users.deleteUser(guest.id);\nconst after = await clerk.organizations.getOrganizationMembershipList({ organizationId: org.id, limit: 100 });\nassert.equal(after.totalCount, 1);\nassert.equal(after.data[0].publicUserData.userId, owner.id);\nwriteFileSync('workflow-receipt.json', JSON.stringify({ owner: owner.id, organization: org.id, deletedMember: guest.id, remainingMemberships: after.totalCount, tokenVerified: true }, null, 2) + '\\n');\nconsole.log('Clerk SDK user, membership, signed token and deletion journey passed');\n",
+    "readback.mjs": "import assert from 'node:assert/strict';\nimport { readFileSync } from 'node:fs';\nimport { createClerkClient } from '@clerk/backend';\n\nassert.ok(process.env.VOLTER_WORLD);\nconst previous = JSON.parse(readFileSync('workflow-receipt.json', 'utf8'));\nconst clerk = createClerkClient({ secretKey: process.env.CLERK_SECRET_KEY });\nconst owner = await clerk.users.getUser(previous.owner);\nassert.equal(owner.emailAddresses[0].emailAddress, 'owner@catalog-clerk.example');\nconst memberships = await clerk.organizations.getOrganizationMembershipList({ organizationId: previous.organization, limit: 100 });\nassert.equal(memberships.totalCount, 1);\nassert.equal(memberships.data[0].publicUserData.userId, previous.owner);\nassert.ok(memberships.data.every(member => member.publicUserData.userId !== previous.deletedMember));\nconsole.log(JSON.stringify({ retained: true, organization: previous.organization, remainingMemberships: memberships.totalCount }));\n"
+  },
+  "run": [
+    "node",
+    "workflow.mjs"
+  ],
+  "retention": {
+    "readback": [
+      "node",
+      "readback.mjs"
+    ]
+  }
+}

package/dist/src/clients/cloudflare.first-use.json

@@ -0,0 +1,21 @@
+{
+  "schemaVersion": 1,
+  "source": "https://www.npmjs.com/package/cloudflare/v/7.2.0",
+  "about": "Create a zone and DNS record through the official SDK, then read the retained record after restart.",
+  "files": {
+    "package.json": "{\n  \"name\": \"cloudflare-installed-customer\",\n  \"private\": true,\n  \"type\": \"module\",\n  \"dependencies\": {\n    \"cloudflare\": \"7.2.0\"\n  }\n}\n",
+    ".env.example": "CLOUDFLARE_API_TOKEN=\nCLOUDFLARE_ACCOUNT_ID=\n",
+    "resume.mjs": "import assert from 'node:assert/strict';\nimport { readFileSync, writeFileSync } from 'node:fs';\nimport Cloudflare from 'cloudflare';\nassert.ok(process.env.VOLTER_WORLD);\nconst held = JSON.parse(readFileSync('first-use-receipt.json', 'utf8'));\nconst client = new Cloudflare({ apiToken: process.env.CLOUDFLARE_API_TOKEN, maxRetries: 0 });\nconst saved = await client.dns.records.get(held.record, { zone_id: held.zone });\nassert.equal(saved.content, '192.0.2.10');\nconst receipt = { passed: true, scope: 'down/up retains DNS record and World-issued credentials remain usable',     };\nwriteFileSync('resume-receipt.json', JSON.stringify(receipt, null, 2) + '\\n');\nconsole.log(JSON.stringify(receipt));\n",
+    "app.mjs": "import assert from 'node:assert/strict';\nimport { writeFileSync } from 'node:fs';\nimport Cloudflare from 'cloudflare';\nassert.ok(process.env.VOLTER_WORLD);\nconst client = new Cloudflare({ apiToken: process.env.CLOUDFLARE_API_TOKEN, maxRetries: 0 });\nconst zone = await client.zones.create({ account: { id: process.env.CLOUDFLARE_ACCOUNT_ID }, name: 'first-user.example', type: 'full' });\nconst record = await client.dns.records.create({ zone_id: zone.id, type: 'A', name: 'www.first-user.example', content: '192.0.2.10', ttl: 1, proxied: true });\nconst saved = await client.dns.records.get(record.id, { zone_id: zone.id });\nassert.equal(saved.name, 'www.first-user.example');\nassert.equal(saved.content, '192.0.2.10');\nassert.equal(saved.proxied, true);\nconst receipt = { passed: true, scope: 'fresh published CLI init/up/run/log/down; unchanged official Cloudflare SDK zone create and DNS write/read',     zone: zone.id, record: record.id,  };\nwriteFileSync('first-use-receipt.json', JSON.stringify(receipt, null, 2) + '\\n');\nconsole.log(JSON.stringify(receipt));\n"
+  },
+  "run": [
+    "node",
+    "app.mjs"
+  ],
+  "retention": {
+    "readback": [
+      "node",
+      "resume.mjs"
+    ]
+  }
+}

package/dist/src/clients/github.first-use.json

@@ -0,0 +1,21 @@
+{
+  "schemaVersion": 1,
+  "source": "https://www.npmjs.com/package/@octokit/rest/v/22.0.1",
+  "about": "Create a repository and issue through Octokit, inspect a missing issue refusal, then read the retained issue after restart.",
+  "files": {
+    "package.json": "{\n  \"name\": \"github-installed-customer\",\n  \"private\": true,\n  \"type\": \"module\",\n  \"dependencies\": {\n    \"@octokit/rest\": \"22.0.1\"\n  }\n}\n",
+    ".env.example": "GITHUB_TOKEN=\n",
+    "resume.mjs": "import assert from 'node:assert/strict';\nimport { readFileSync, writeFileSync } from 'node:fs';\nimport { Octokit } from '@octokit/rest';\nassert.ok(process.env.VOLTER_WORLD);\nconst prior = JSON.parse(readFileSync('first-use-receipt.json', 'utf8'));\nconst client = new Octokit({ auth: process.env.GITHUB_TOKEN });\nconst saved = (await client.rest.issues.get({ owner: prior.owner, repo: prior.repo, issue_number: prior.issue })).data;\nassert.equal(saved.title, prior.title);\nconst receipt = { passed: true, scope: 'ordinary down then up retains stored GitHub issue and usable throwaway credentials',   title: saved.title, issue: saved.number, };\nwriteFileSync('resume-receipt.json', JSON.stringify(receipt, null, 2) + '\\n');\nconsole.log(JSON.stringify(receipt));\n",
+    "app.mjs": "import assert from 'node:assert/strict';\nimport { writeFileSync } from 'node:fs';\nimport { Octokit } from '@octokit/rest';\nassert.ok(process.env.VOLTER_WORLD, 'Run the app through its World');\nassert.ok(process.env.GITHUB_TOKEN, 'The World supplies a throwaway token');\nconst client = new Octokit({ auth: process.env.GITHUB_TOKEN });\nconst created = await client.graphql('mutation($name: String!) { createRepository(input: { name: $name, visibility: PUBLIC }) { repository { nameWithOwner } } }', { name: 'first-catalog-app' });\nconst [owner, repo] = created.createRepository.repository.nameWithOwner.split('/');\nconst made = (await client.rest.issues.create({ owner, repo, title: 'First local issue', body: 'Created through the real Octokit SDK inside a World.' })).data;\nconst saved = (await client.rest.issues.get({ owner, repo, issue_number: made.number })).data;\nassert.equal(saved.title, made.title);\nassert.equal(saved.body, made.body);\nassert.equal(saved.state, 'open');\nawait assert.rejects(() => client.rest.issues.get({ owner, repo, issue_number: 99999 }), error => error.status === 404);\nconst receipt = { passed: true, scope: 'fresh published CLI init/up/run/log/down with unmodified Octokit; repository create and issue write/read/missing read',     owner, repo, issue: saved.number, title: saved.title,  };\nwriteFileSync('first-use-receipt.json', JSON.stringify(receipt, null, 2) + '\\n');\nconsole.log(JSON.stringify(receipt));\n"
+  },
+  "run": [
+    "node",
+    "app.mjs"
+  ],
+  "retention": {
+    "readback": [
+      "node",
+      "resume.mjs"
+    ]
+  }
+}

package/dist/src/clients/openai.first-use.json

@@ -0,0 +1,17 @@
+{
+  "schemaVersion": 1,
+  "source": "https://www.npmjs.com/package/openai/v/7.28.0",
+  "about": "Use the official SDK for Chat Completions and SSE streaming, checking the explicitly labeled model stub.",
+  "files": {
+    "package.json": "{\n  \"name\": \"openai-installed-customer\",\n  \"private\": true,\n  \"type\": \"module\",\n  \"dependencies\": {\n    \"openai\": \"7.28.0\"\n  }\n}\n",
+    ".env.example": "OPENAI_API_KEY=\n",
+    "app.mjs": "import OpenAI from 'openai';\nimport assert from 'node:assert/strict';\nimport {writeFileSync} from 'node:fs';\nassert.ok(process.env.VOLTER_WORLD,'run through the World');\nconst client=new OpenAI({apiKey:process.env.OPENAI_API_KEY,maxRetries:0});\nconst input={model:'gpt-4o',messages:[{role:'user',content:'first-user deterministic fixture'}]};\nconst answer=await client.chat.completions.create(input);\nconst text=answer.choices[0].message.content;\nassert.match(text,/\\[twin-stub:/);\nassert.equal(answer.choices[0].message.role,'assistant');\nassert.equal(answer.choices[0].finish_reason,'stop');\nlet streamed='';\nfor await(const event of await client.chat.completions.create({...input,stream:true})) streamed+=event.choices[0]?.delta?.content??'';\nassert.equal(streamed,text);\nconst receipt={passed:true,scope:'unchanged official OpenAI SDK Chat Completions and SSE stream; labeled default model stub; no generated prose quality or Realtime/browser claim',};\nwriteFileSync('first-use-receipt.json',JSON.stringify(receipt,null,2)+'\\n');console.log(JSON.stringify(receipt));\n"
+  },
+  "run": [
+    "node",
+    "app.mjs"
+  ],
+  "retention": {
+    "none": "This workflow requests an unstored completion and stream; it creates no vendor resource to read after restart."
+  }
+}

package/dist/src/clients/resend.first-use.json

@@ -0,0 +1,25 @@
+{
+  "schemaVersion": 1,
+  "source": "https://www.npmjs.com/package/resend/v/6.6.0",
+  "about": "Send a synthetic sign-in email through the official SDK and inspect the retained message and local inbox after restart. Advance the frozen World clock to settle synthetic delivery before retained-state inspection.",
+  "files": {
+    "package.json": "{\n  \"name\": \"resend-installed-customer\",\n  \"private\": true,\n  \"type\": \"module\",\n  \"dependencies\": {\n    \"resend\": \"6.6.0\"\n  }\n}\n",
+    ".env.example": "RESEND_API_KEY=\n",
+    "inspect-email.mjs": "import assert from 'node:assert/strict';\nimport { readFileSync } from 'node:fs';\nimport { Resend } from 'resend';\n\nassert.ok(process.env.VOLTER_WORLD, 'run this script through the World');\nconst { id } = JSON.parse(readFileSync('last-email.json', 'utf8'));\nconst resend = new Resend(process.env.RESEND_API_KEY);\nconst saved = await resend.emails.get(id);\nassert.equal(saved.error, null);\nassert.equal(saved.data.last_event, 'delivered');\nconst response = await fetch(`${process.env.RESEND_TWIN_URL}/_twin/mail?to=owner%40world.test`);\nassert.equal(response.status, 200);\nconst inbox = await response.json();\nconst email = inbox.mail.find((message) => message.id === id);\nassert.ok(email, 'the delivered message must be in the local inbox');\nassert.equal(email.subject, 'Your local sign-in code');\nassert.match(email.text, /123456/);\nassert.match(email.html, /<strong>123456<\\/strong>/);\nconsole.log('local inbox contains the delivered email and sign-in code');\n",
+    "send-email.mjs": "import assert from 'node:assert/strict';\nimport { writeFileSync } from 'node:fs';\nimport { Resend } from 'resend';\n\nassert.ok(process.env.VOLTER_WORLD, 'run this script through the World');\nconst resend = new Resend(process.env.RESEND_API_KEY);\nconst email = {\n  from: 'Example app <onboarding@resend.dev>',\n  to: ['owner@world.test'],\n  subject: 'Your local sign-in code',\n  text: 'Your synthetic sign-in code is 123456.',\n  html: '<p>Your synthetic sign-in code is <strong>123456</strong>.</p>'\n};\nconst sent = await resend.emails.send(email);\nassert.equal(sent.error, null);\nassert.ok(sent.data.id);\nconst saved = await resend.emails.get(sent.data.id);\nassert.equal(saved.error, null);\nassert.equal(saved.data.id, sent.data.id);\nassert.equal(saved.data.subject, email.subject);\nassert.equal(saved.data.text, email.text);\nassert.deepEqual(saved.data.to, email.to);\nwriteFileSync('last-email.json', JSON.stringify({ id: sent.data.id }) + '\\n');\nconsole.log('email sent and read back locally');\n"
+  },
+  "run": [
+    "node",
+    "send-email.mjs"
+  ],
+  "retention": {
+    "readback": [
+      "node",
+      "inspect-email.mjs"
+    ]
+  },
+  "clock": {
+    "at": "2026-10-06T12:00:00Z",
+    "advanceAfterRun": "10s"
+  }
+}

package/dist/src/clients/run.js

@@ -16,6 +16,8 @@ import { fileURLToPath } from 'node:url';
 import { clientContext, worldProxy } from "./harness.js";
 const job = JSON.parse(readFileSync(process.argv[2], 'utf8'));
 const { cases } = (await import(__rewriteRelativeImportExtension(`./${job.vendor}${extname(fileURLToPath(import.meta.url))}`)));
+if (!Array.isArray(cases) || cases.length === 0)
+    throw new Error(`${job.vendor} client module declares no cases; there is no SDK execution evidence`);
 // every connection a case makes goes through the World's proxy, as an application's does in a World
 const proxy = await worldProxy(job.port);
 // Bind only this artifact's declared vendor hosts to the assessed server. The enclosing World's

package/dist/src/clients/slack.first-use.json

@@ -0,0 +1,21 @@
+{
+  "schemaVersion": 1,
+  "source": "https://www.npmjs.com/package/@slack/web-api/v/7.19.0",
+  "about": "Create a Slack Connect invitation through the official SDK, then inspect the retained invitation after restart.",
+  "files": {
+    "package.json": "{\n  \"name\": \"slack-installed-customer\",\n  \"private\": true,\n  \"type\": \"module\",\n  \"dependencies\": {\n    \"@slack/web-api\": \"7.19.0\"\n  }\n}\n",
+    ".env.example": "SLACK_BOT_TOKEN=\nSLACK_APP_TOKEN=\nSLACK_SIGNING_SECRET=\n",
+    "readback.mjs": "import assert from 'node:assert/strict';\nimport {readFileSync} from 'node:fs';\nimport {WebClient} from '@slack/web-api';\nconst old=JSON.parse(readFileSync('workflow-receipt.json','utf8'));\nconst slack=new WebClient(process.env.SLACK_BOT_TOKEN);\nconst identity=await slack.auth.test();\nassert.equal(identity.team,'World');\nconst pending=await slack.conversations.listConnectInvites({count:1});\nassert.equal(pending.invites[0].invite.id,old.invitation);\nassert.equal(pending.invites[0].channel.id,old.channel);\nconsole.log(JSON.stringify({retained:true,workspace:identity.team,invitation:old.invitation}));\n",
+    "workflow.mjs": "import assert from 'node:assert/strict';\nimport { writeFileSync } from 'node:fs';\nimport { WebClient } from '@slack/web-api';\nassert.ok(process.env.VOLTER_WORLD);\nconst slack = new WebClient(process.env.SLACK_BOT_TOKEN);\nconst identity = await slack.auth.test();\nconst channel = await slack.conversations.create({ name: 'catalog-first-user-support' });\nconst invitation = await slack.conversations.inviteShared({ channel: channel.channel.id, emails: ['customer@outside.test'], external_limited: true });\nconst pending = await slack.conversations.listConnectInvites({ count: 1 });\nassert.equal(pending.invites[0].invite.id, invitation.invite_id);\nassert.equal(pending.invites[0].channel.id, channel.channel.id);\nwriteFileSync('workflow-receipt.json', JSON.stringify({ identity: { team_id: identity.team_id, team: identity.team }, channel: channel.channel.id, invitation: invitation.invite_id, pending: true }, null, 2) + '\\n');\n"
+  },
+  "run": [
+    "node",
+    "workflow.mjs"
+  ],
+  "retention": {
+    "readback": [
+      "node",
+      "readback.mjs"
+    ]
+  }
+}

package/dist/src/clients/stripe.first-use.json

@@ -0,0 +1,21 @@
+{
+  "schemaVersion": 1,
+  "source": "https://www.npmjs.com/package/stripe/v/17.7.0",
+  "about": "Create and retrieve a customer through the official SDK. Read the retained customer after restart.",
+  "files": {
+    "package.json": "{\n  \"name\": \"stripe-installed-customer\",\n  \"private\": true,\n  \"type\": \"module\",\n  \"dependencies\": {\n    \"stripe\": \"17.7.0\"\n  }\n}\n",
+    ".env.example": "STRIPE_SECRET_KEY=\n",
+    "signup.mjs": "import { writeFileSync } from 'node:fs';\nimport assert from 'node:assert/strict';\nimport Stripe from 'stripe';\n\nassert.ok(process.env.VOLTER_WORLD);\nconst stripe = new Stripe(process.env.STRIPE_SECRET_KEY);\nconst customer = await stripe.customers.create({ email: 'ada@example.com', name: 'Ada' });\nconst saved = await stripe.customers.retrieve(customer.id);\nassert.equal(saved.email, 'ada@example.com');\nassert.equal(saved.name, 'Ada');\nconsole.log(`created ${customer.id}`);\nconsole.log('customer read-back passed');\nwriteFileSync('customer.json', JSON.stringify({ id: customer.id }) + '\\n');\n",
+    "readback.mjs": "import assert from 'node:assert/strict';\nimport { readFileSync } from 'node:fs';\nimport Stripe from 'stripe';\nassert.ok(process.env.VOLTER_WORLD);\nconst { id } = JSON.parse(readFileSync('customer.json', 'utf8'));\nconst stripe = new Stripe(process.env.STRIPE_SECRET_KEY);\nconst saved = await stripe.customers.retrieve(id);\nassert.equal(saved.email, 'ada@example.com');\nassert.equal(saved.name, 'Ada');\nconsole.log('retained customer read-back passed');\n"
+  },
+  "run": [
+    "node",
+    "signup.mjs"
+  ],
+  "retention": {
+    "readback": [
+      "node",
+      "readback.mjs"
+    ]
+  }
+}

package/dist/src/clients/supabase.first-use.json

@@ -0,0 +1,21 @@
+{
+  "schemaVersion": 1,
+  "source": "https://www.npmjs.com/package/pg/v/8.16.3",
+  "about": "Use the issued Supabase database connection with unchanged node-postgres: schema, write and read, then read retained data after restart. This does not establish Supabase HTTP client compatibility.",
+  "files": {
+    "package.json": "{\n  \"name\": \"supabase-installed-customer\",\n  \"private\": true,\n  \"type\": \"module\",\n  \"dependencies\": {\n    \"pg\": \"8.16.3\"\n  }\n}\n",
+    ".env.example": "SUPABASE_DB_URL=\n",
+    "app.mjs": "import pg from 'pg';\nimport assert from 'node:assert/strict';\nimport {writeFileSync} from 'node:fs';\nassert.ok(process.env.VOLTER_WORLD,'run through the World');\nassert.ok(process.env.SUPABASE_DB_URL,'the World must issue the database URL');\nconst client=new pg.Client({connectionString:process.env.SUPABASE_DB_URL});\nawait client.connect();\ntry {\n if(process.argv[2]!=='resumed'){\n await client.query('CREATE TABLE IF NOT EXISTS catalog_signup (id text PRIMARY KEY, email text NOT NULL)');\n await client.query('INSERT INTO catalog_signup (id,email) VALUES ($1,$2) ON CONFLICT (id) DO NOTHING',['new-user','new-user@example.test']);\n }\n const {rows}=await client.query('SELECT id,email FROM catalog_signup WHERE id=$1',['new-user']);\n assert.deepEqual(rows,[{id:'new-user',email:'new-user@example.test'}]);\n const receipt={passed:true,phase:process.argv[2]??'first-boot',scope:'unchanged node-postgres client; project credential issuance and native PostgreSQL schema, insert and readback; no Supabase HTTP data-plane claim',};\n writeFileSync(`first-use-${receipt.phase}.json`,JSON.stringify(receipt,null,2)+'\\n');console.log(JSON.stringify(receipt));\n} finally {await client.end();}\n"
+  },
+  "run": [
+    "node",
+    "app.mjs"
+  ],
+  "retention": {
+    "readback": [
+      "node",
+      "app.mjs",
+      "resumed"
+    ]
+  }
+}

package/dist/src/clients/tavily.first-use.json

@@ -0,0 +1,17 @@
+{
+  "schemaVersion": 1,
+  "source": "https://www.npmjs.com/package/@tavily/core/v/0.7.14",
+  "about": "Seed an explicitly synthetic World page through its existing door, then search and extract through the official SDK. No public web or model runs.",
+  "files": {
+    "package.json": "{\n  \"name\": \"tavily-installed-customer\",\n  \"private\": true,\n  \"type\": \"module\",\n  \"dependencies\": {\n    \"@tavily/core\": \"0.7.14\"\n  }\n}\n",
+    ".env.example": "TAVILY_API_KEY=\n",
+    "workflow.mjs": "import assert from 'node:assert/strict';\nimport { tavily } from '@tavily/core';\nassert.ok(process.env.VOLTER_WORLD);\nconst page = { url: 'https://schedule.example/yoga', title: 'Yoga schedule', content: 'Yoga on Tuesdays at 18:00.' };\nconst setup = await fetch('https://api.tavily.com/_twin/pages', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(page) });\nassert.equal(setup.status, 201);\nconst client = tavily({ apiKey: process.env.TAVILY_API_KEY });\nconst search = await client.search('Yoga schedule', { includeAnswer: true });\nassert.equal(search.results[0].url, page.url);\nassert.match(search.answer, /\\[twin-stub\\]/);\nconst extract = await client.extract([page.url]);\nassert.equal(extract.results[0].url, page.url);\nassert.match(extract.results[0].rawContent, /Yoga on Tuesdays/);\nconsole.log('Official Tavily SDK search and extract over the synthetic World corpus passed');\n"
+  },
+  "run": [
+    "node",
+    "workflow.mjs"
+  ],
+  "retention": {
+    "none": "Search and extraction create no stored Tavily resource; the pages door supplies synthetic World corpus, not vendor state."
+  }
+}

package/dist/src/clients/upstash.first-use.json

@@ -0,0 +1,21 @@
+{
+  "schemaVersion": 1,
+  "source": "https://www.npmjs.com/package/@upstash/redis/v/1.38.2",
+  "about": "Store and read a profile and counter through the Redis SDK, then inspect both after restart.",
+  "files": {
+    "package.json": "{\n  \"name\": \"upstash-installed-customer\",\n  \"private\": true,\n  \"type\": \"module\",\n  \"dependencies\": {\n    \"@upstash/redis\": \"1.38.2\"\n  }\n}\n",
+    ".env.example": "UPSTASH_REDIS_REST_URL=\nUPSTASH_REDIS_REST_TOKEN=\n",
+    "resume.mjs": "import assert from 'node:assert/strict';\nimport { writeFileSync } from 'node:fs';\nimport { Redis } from '@upstash/redis';\nassert.ok(process.env.VOLTER_WORLD);\nconst redis = Redis.fromEnv();\nassert.deepEqual(await redis.get('first-user:profile'), { email: 'first-user@example.test', plan: 'free' });\nassert.equal(await redis.get('first-user:visits'), 1);\nconst receipt = { passed: true, scope: 'down/up retains Redis data and throwaway credentials remain usable',     };\nwriteFileSync('resume-receipt.json', JSON.stringify(receipt, null, 2) + '\\n');\nconsole.log(JSON.stringify(receipt));\n",
+    "app.mjs": "import assert from 'node:assert/strict';\nimport { writeFileSync } from 'node:fs';\nimport { Redis } from '@upstash/redis';\nassert.ok(process.env.VOLTER_WORLD);\nconst redis = Redis.fromEnv();\nconst value = { email: 'first-user@example.test', plan: 'free' };\nassert.equal(await redis.set('first-user:profile', value), 'OK');\nassert.deepEqual(await redis.get('first-user:profile'), value);\nassert.equal(await redis.incr('first-user:visits'), 1);\nassert.equal(await redis.get('first-user:missing'), null);\nconst receipt = { passed: true, scope: 'fresh published CLI init/up/run/log/down; unchanged official Redis SDK set/get/incr/missing read',      };\nwriteFileSync('first-use-receipt.json', JSON.stringify(receipt, null, 2) + '\\n');\nconsole.log(JSON.stringify(receipt));\n"
+  },
+  "run": [
+    "node",
+    "app.mjs"
+  ],
+  "retention": {
+    "readback": [
+      "node",
+      "resume.mjs"
+    ]
+  }
+}

package/dist/src/conformance.js

@@ -467,6 +467,8 @@ async function clientCases(pack, scratch) {
             child.on('close', (code) => { clearTimeout(timer); resolve(code === 0 ? text : `${text}\n${JSON.stringify({ id: 'runner', asks: 'the cases run', failures: [`node exited ${code}: ${errors.trim().split('\n').slice(0, 12).join(' ')}`] })}`); });
         });
         const results = out.split('\n').filter((l) => l.startsWith('{')).map((l) => JSON.parse(l));
+        if (results.length === 0)
+            return { failures: [`${vendor} client runner returned no case results; there is no SDK execution evidence`] };
         return { failures: results.flatMap((r) => r.failures.map((f) => `${r.id} (${r.asks}): ${f}`)), note: `${results.length} case(s) through the vendor's client` };
     }
     finally {

package/dist/src/consumer.d.ts

@@ -0,0 +1,67 @@
+export type ConsumerRecipe = {
+    schemaVersion: 1;
+    source: string;
+    about: string;
+    files: Record<string, string>;
+    clock?: {
+        at: string;
+        advanceAfterRun?: string;
+    };
+    run: string[];
+    retention: {
+        readback: string[];
+    } | {
+        none: string;
+    };
+};
+export type ConsumerOptions = {
+    appDir: string;
+    cli: string;
+    artifactIntegrity: string;
+};
+/** Bind behavior inputs on both source and packed layouts; compiled outputs and score caches are not inputs. */
+export declare function consumerSourceDigest(pack: string): string;
+/** A pack supplies its own entry journey; older immutable releases use a versioned standard fixture. */
+export declare function consumerRecipe(vendor: string, packDir?: string): ConsumerRecipe;
+/** Materialize only a new caller-owned app. Normal dependency installation happens before offline assessment. */
+export declare function prepareConsumerApp(packDir: string, appDir: string): {
+    recipeSha256: string;
+    dependencies: Record<string, string>;
+};
+export declare function runConsumerWorkflow(packDir: string, options: ConsumerOptions): Promise<{
+    node: string;
+    at: string;
+    retentionNotApplicable?: string | undefined;
+    measured: boolean;
+    passed: boolean;
+    scope: string;
+    package: any;
+    version: any;
+    integrity: string;
+    tools: {
+        '@volter/world': string;
+        '@volter/world-core': string;
+        '@volter/world-runtime': string;
+    };
+    sourceInputsSha256: string;
+    recipeSha256: string;
+    fixture: string;
+    appDir: string;
+    appName: string;
+    commands: {
+        label: string;
+        argv: string[];
+        exitCode: number | null;
+        stdout: string;
+        stderr: string;
+    }[];
+    failures: string[];
+    teardownVerified: boolean;
+    retainedReadback: boolean;
+    clock: {
+        at: string;
+        advanceAfterRun?: string;
+    } | {
+        mode: string;
+    };
+}>;