@pouchy_ai/world-sdk 0.18.0 → 0.20.0

package/CHANGELOG.md

@@ -1,5 +1,51 @@
 # @pouchy_ai/world-sdk
 
+## 0.20.0
+
+- **Seven methods for routes that already existed.** `getWorldOverview`,
+  `getWorldCost`, `listWorldVersions`, `listStoryPackageVersions`,
+  `setWorldDisabled`, `setStoryPackageDisabled` (all `adminKey`-capable), and
+  `preflightWorld` (owner plane only — no `/admin` mirror).
+- **Two of them the README already promised.** Its credential table listed
+  `overview` and `cost` as `adminKey` reads, and there was no method to make
+  them with. `getWorldOverview` is the one to reach for first: it carries
+  `ready` and the `blockers` behind a false, and unlike `preflightWorld` a
+  machine can call it.
+- **`conformance.mjs` no longer fails a correctly-configured project.** Its
+  header claimed an admin key was enough; two of its own gates call
+  `replayLedgerToEnd` and `createScriptDraft`, whose routes have no `/admin`
+  mirror, so on a key alone they threw "needs an owner token". Those gates now
+  SKIP with the reason printed, and skips are counted apart from passes rather
+  than folded into the ratio.
+- No API change — `WORLD_API_VERSION` stays at 1.24.0. Every route these
+  methods call has been served on both planes since Batch 1; only the client
+  was missing.
+
+## 0.19.0
+
+- `getApprovedExport(environmentId, worldInstanceId, draftId, editorialId, exportId)`
+  — **read an approved script, body included, from a backend.** With `adminKey`
+  set it goes to the `/admin` mirror and needs no browser anywhere in your
+  deployment; same mechanism as `getProgress` and `getTurn`.
+- **This closes the loop.** Until now nothing returned an export body: the
+  collection listing strips it, so the only response that ever carried a script
+  was the POST that minted one. Reading required the create verb and an
+  hour-lived browser token, which meant a person had to forward the file.
+- **Every field the call needs is in the `world.script_approved` webhook** —
+  `exportId` at the top level, and `environmentId`, `worldInstanceId`,
+  `evidenceDraftId`, `editorialDraftId` inside `lineage`. Webhook → read, with
+  nobody in the middle. The payload still carries no script.
+- **Creating an export is still a human act** and is deliberately NOT mirrored:
+  an export is a reviewer's signature on a specific text. `deriveStoryPackageCandidate`
+  is not mirrored either — it leads to published canon.
+- New `ApprovedScriptExportSummary`, and `listApprovedExports` is now typed with
+  it instead of `unknown[]`. **The summary carries no `content`** — that is the
+  point of the split, and treating one as a full row is now a compile error
+  rather than a crash reading `content.exportDigest` off `undefined`.
+- Any miss on the item read — wrong project, environment, instance, draft,
+  editorial, or no such id — answers the **same** 404, so refusals cannot be used
+  to map which objects exist.
+
 ## 0.18.0
 
 - `createApprovedExport({ version: 2 })` — the V2 production hand-off: a

package/README.md

@@ -52,7 +52,10 @@ directions a beat could take, then commit the one the player picked. Off unless
 the world's published revision declares it; the `envelope` is server-side only.
 
 **Reading** — `getWorldState`, `getProgress`, `getTurn`, `listTurns`,
-`listTurnsSince`, `replayLedger`, `replayLedgerToEnd`, `scanConsistency`.
+`listTurnsSince`, `replayLedger`, `replayLedgerToEnd`, `scanConsistency`,
+`getWorldOverview`, `getWorldCost`, `listWorldVersions`,
+`listStoryPackageVersions`, `setWorldDisabled`, `setStoryPackageDisabled`,
+`preflightWorld`.
 
 **Which credential does what.** This matters more than it looks: one of them
 expires within the hour.
@@ -64,9 +67,22 @@ expires within the hour.
 | `adminToken` (Firebase ID token, ~1h) | everything above plus the content loop | outlive the hour |
 
 A server holds `secretKey` + `signing` + `adminKey` and needs **no browser login
-anywhere in its deployment** — including `conformance.mjs`, which used to demand
-one. `adminToken` is for a person: the content loop's review step is a human
-decision, which is the point of it rather than an obstacle.
+for the runtime loop**: author a story package and a world, mint sessions, drive
+turns, and read everything back. `adminToken` is for a person, and the content
+loop's review step is a human decision — the point of it rather than an obstacle.
+
+**Which calls have no `/admin` mirror, and therefore need `adminToken`:** the
+whole content loop (`*ScriptDraft*`, `*EditorialDraft*`, `createApprovedExport`,
+`deriveStoryPackageCandidate`), the delivery-queue ACTIONS (`drainDeliveries`,
+`requeueDelivery`, `rehydrateDelivery`, `resolveDeliveryGap`), `replayLedger`,
+`archiveLedger`, `evaluateWorld`, and `preflightWorld`. Reading an approved
+export back IS mirrored (`getApprovedExport`) — that is how a machine collects
+what a person approved, with the id arriving on the `world.script_approved`
+webhook.
+
+`conformance.mjs` follows the same line: on an admin key alone it runs every
+runtime gate and SKIPS the two whose routes are owner-plane, printing why.
+Setting `POUCHY_ADMIN_TOKEN` as well runs all of them.
 
 ```ts
 const world = new PouchyWorldClient({
@@ -160,7 +176,7 @@ copies, and `prune` — the one call here that deletes — refuses without
 `confirm`, and again unless the archive verifies and has outlived retention.
 
 **Production hand-off** — `createApprovedExport`, `listApprovedExports`,
-`deriveStoryPackageCandidate`. An approved editorial draft becomes a versioned
+`getApprovedExport`, `deriveStoryPackageCandidate`. An approved editorial draft becomes a versioned
 approved script export carrying the whole chain: original story package → world
 instance → ledger range → evidence draft → editorial draft → reviewer.
 Idempotent on content, so replaying an export is a no-op.
@@ -177,6 +193,14 @@ yields two different, individually stable ids. `content` is a union — narrow o
 `contractVersion` before reading version-specific fields, and expect an
 unrecognised `version` to be a 400 rather than a quiet fall back to 1.
 
+`listApprovedExports` returns **summaries** — identity, provenance, a scene
+count, and no script. `getApprovedExport` returns **one export with its body**,
+and it is the call an unattended backend makes: with `adminKey` set it routes to
+the `/admin` mirror, so no browser is involved anywhere in your deployment.
+Everything it needs arrives in the `world.script_approved` webhook, so the loop
+closes without a person in the middle. Creating an export is deliberately NOT on
+that lane — an export is a reviewer's signature on a specific text.
+
 The Story Package candidate is validated and *returned*; publishing it is a
 separate act by a person, and only evidence-origin material becomes canon. It
 takes **version 1 exports only** and refuses a V2 export with 422 — it is the

package/conformance.mjs

@@ -94,12 +94,26 @@ console.log(`Pouchy World conformance — ${scenario.label} scenario\n`);
 const results = [];
 let failed = false;
 
+/** Marks a gate that CANNOT run on the credentials in hand.
+ *
+ *  Not a pass and not a failure. Two gates below drive the content loop and
+ *  the ledger replay, and neither route has an `/admin` mirror — they are
+ *  owner-plane by design ("creating stays human, reading does not"). Reporting
+ *  them as FAIL would make a correctly-configured project look broken; leaving
+ *  them out silently would make a partial run look complete. */
+class NeedsOwnerToken extends Error {}
+
 async function check(name, fn) {
 	try {
 		const detail = await fn();
 		results.push({ name, ok: true, detail });
 		console.log(`PASS  ${name}${detail ? ` — ${detail}` : ''}`);
 	} catch (err) {
+		if (err instanceof NeedsOwnerToken) {
+			results.push({ name, ok: null, detail: err.message });
+			console.log(`SKIP  ${name} — ${err.message}`);
+			return;
+		}
 		failed = true;
 		const detail =
 			err instanceof WorldApiError
@@ -114,14 +128,21 @@ async function check(name, fn) {
 
 const world = new PouchyWorldClient({
 	projectId: env('POUCHY_PROJECT_ID'),
-	// Batch 10: an ADMIN KEY is enough, and is the point.
+	// Batch 10: an ADMIN KEY carries the RUNTIME loop, which is the point.
 	//
 	// This harness used to demand POUCHY_ADMIN_TOKEN — a Firebase ID token,
 	// browser-minted and good for about an hour. So the one check that proves a
 	// project's world plane is wired correctly could not run without a person
 	// opening a browser first, which is exactly the thing the rest of this SDK
-	// stopped requiring. Either credential works now; the key is preferred and
-	// needs no human.
+	// stopped requiring.
+	//
+	// CORRECTED: "either credential works" was too strong, and this file was the
+	// proof — two of its own gates call `replayLedgerToEnd` and
+	// `createScriptDraft`, whose routes have NO `/admin` mirror. On an admin key
+	// alone they threw "needs an owner token", so the harness could not pass a
+	// correctly-configured project. Those two gates now SKIP with the reason
+	// printed; every runtime gate runs on the key. Set POUCHY_ADMIN_TOKEN as
+	// well to run all of them.
 	...(process.env.POUCHY_ADMIN_KEY
 		? { adminKey: process.env.POUCHY_ADMIN_KEY }
 		: { adminToken: env('POUCHY_ADMIN_TOKEN') }),
@@ -133,6 +154,15 @@ const world = new PouchyWorldClient({
 	},
 	...(process.env.POUCHY_BASE_URL ? { baseUrl: process.env.POUCHY_BASE_URL } : {})
 });
+/** Throws a SKIP for a gate whose route is owner-plane only. */
+function requireOwnerToken(route) {
+	if (!process.env.POUCHY_ADMIN_TOKEN) {
+		throw new NeedsOwnerToken(
+			`${route} has no /admin mirror — set POUCHY_ADMIN_TOKEN to run this gate`
+		);
+	}
+}
+
 const agentA = env('POUCHY_AGENT_A');
 const agentB = env('POUCHY_AGENT_B');
 const stamp = Date.now().toString(36);
@@ -237,6 +267,7 @@ await check('world state reads back (user projection, no private layer)', async
 });
 
 await check('replay verifies the ledger against the served state', async () => {
+	requireOwnerToken('/ledger/replay');
 	const report = await world.replayLedgerToEnd(created.environmentId, instanceId);
 	if (report.verdict !== 'consistent') {
 		throw new Error(`${report.verdict}${report.detail ? `: ${report.detail}` : ''}`);
@@ -246,6 +277,7 @@ await check('replay verifies the ledger against the served state', async () => {
 });
 
 await check('a script draft generates and refuses export before review', async () => {
+	requireOwnerToken('/script-drafts');
 	const draft = await world.createScriptDraft(created.environmentId, instanceId);
 	if (draft.content?.humanReviewRequired !== true) {
 		throw new Error('draft did not carry humanReviewRequired');
@@ -284,9 +316,24 @@ await check('a WRONG signature is refused (the second proof is real)', async ()
 });
 
 console.log('');
-console.log(`${results.filter((r) => r.ok).length}/${results.length} checks passed`);
+// SKIPPED is counted apart from PASSED, never folded into a ratio. A gate that
+// could not run is not a gate that passed, and "8/10 passed" would read as two
+// failures — the opposite of what happened.
+const passed = results.filter((r) => r.ok === true).length;
+const skipped = results.filter((r) => r.ok === null).length;
+const ran = results.length - skipped;
+console.log(
+	`${passed}/${ran} checks passed` + (skipped ? ` · ${skipped} skipped (no owner token)` : '')
+);
 if (failed) {
 	console.error('Conformance FAILED — fix the first failure above before writing product code.');
 	process.exit(1);
 }
-console.log('Conformance passed. The world plane is wired correctly for this project.');
+if (skipped) {
+	console.log(
+		`The RUNTIME plane is wired correctly. ${skipped} content-loop gate(s) did not run: ` +
+			`their routes are owner-plane only. Set POUCHY_ADMIN_TOKEN to cover them too.`
+	);
+} else {
+	console.log('Conformance passed. The world plane is wired correctly for this project.');
+}

package/dist/index.d.ts

@@ -4,7 +4,7 @@
  *  a project is running — which is exactly the field you reach for when a
  *  customer's integration behaves like an older SDK than they say they have.
  *  It sat at '0.1.0' for eight releases before anything compared the two. */
-export declare const WORLD_SDK_VERSION = "0.18.0";
+export declare const WORLD_SDK_VERSION = "0.20.0";
 export declare const DEFAULT_BASE_URL = "https://pouchy.ai/v1";
 /** One direction a beat could take. The WHOLE of what a deliberation shows a
  *  player: no reasoning, no role secrets, no simulated effects, no scores. */
@@ -643,6 +643,29 @@ export interface ApprovedScriptExportContentV2 {
  *  reading anything version-specific; a stored row keeps the version it was
  *  written with, forever. */
 export type ApprovedScriptExportContent = ApprovedScriptExportContentV1 | ApprovedScriptExportContentV2;
+/** Identity and provenance for every export on an editorial draft, WITHOUT the
+ *  script. This is what `listApprovedExports` returns.
+ *
+ *  Split from `ApprovedScriptExportRow` deliberately, and the difference is the
+ *  whole script. Treating a summary as a full row reads `content.exportDigest`
+ *  off `undefined`; keeping them apart makes that a compile error rather than a
+ *  crash in front of a user. To get the body, call `getApprovedExport`. */
+export interface ApprovedScriptExportSummary {
+    exportId: string;
+    draftId: string;
+    editorialId: string;
+    worldInstanceId: string;
+    environmentId: string;
+    /** How many scenes the body carries — the shape of what is not here. */
+    scenes: number;
+    createdAt: string;
+    createdBy: string;
+    deliveredAt?: string;
+    deliveryAttempted?: number;
+    deliveryOk?: number;
+    approvalTimeSource?: 'stamped' | 'legacy_updated_at';
+    approvedContentDigest?: string;
+}
 export interface ApprovedScriptExportRow {
     exportId: string;
     draftId: string;
@@ -655,6 +678,8 @@ export interface ApprovedScriptExportRow {
     deliveredAt?: string;
     deliveryAttempted?: number;
     deliveryOk?: number;
+    approvalTimeSource?: 'stamped' | 'legacy_updated_at';
+    approvedContentDigest?: string;
 }
 /** What `POST /v1/sessions` actually returns for a WORLD mint.
  *
@@ -867,6 +892,63 @@ export declare class PouchyWorldClient {
         contentHash: string;
     }>;
     getWorld(environmentId: string): Promise<unknown>;
+    /** The world's readiness and operational aggregate — what the dashboard's
+     *  World Overview binds to.
+     *
+     *  This is the call to make BEFORE driving anything: `ready` plus the
+     *  `blockers` that explain a false, instance counts, and the delivery
+     *  queue's shape. It was reachable on both planes from the start and simply
+     *  had no method here, which meant the README's own credential table
+     *  promised an `adminKey` read the SDK could not perform. */
+    getWorldOverview(environmentId: string): Promise<unknown>;
+    /** What this world has cost, by month.
+     *
+     *  `months` is clamped server-side; omit it for the default window. */
+    getWorldCost(environmentId: string, months?: number): Promise<unknown>;
+    /** Every published revision of this world.
+     *
+     *  An instance is pinned to the revision it was created on, so this is how a
+     *  backend learns which definition a running story is actually playing. */
+    listWorldVersions(environmentId: string): Promise<{
+        versions: unknown[];
+    }>;
+    /** Every published revision of a story package.
+     *
+     *  The response carries `hasUnsupported` / `unsupportedCount` as well as the
+     *  versions: a history this build cannot read whole is reported as PARTIAL
+     *  rather than passing its newest readable revision off as the newest one.
+     *  Check that flag before treating the last entry as current. */
+    listStoryPackageVersions(packageId: string): Promise<{
+        versions: unknown[];
+        unsupported?: unknown;
+        unsupportedCount?: number;
+        hasUnsupported?: boolean;
+    }>;
+    /** Stop (or restart) a world.
+     *
+     *  A disabled world refuses new sessions and new turns. Existing instances
+     *  are not deleted and their ledgers are untouched — this is a door being
+     *  shut, not history being erased, and passing `false` opens it again. */
+    setWorldDisabled(environmentId: string, disabled: boolean): Promise<{
+        environmentId: string;
+        disabled: boolean;
+    }>;
+    /** Stop (or restart) a story package.
+     *
+     *  Worlds already PINNED to one of its revisions keep running: an instance
+     *  holds its own revision for life. This stops new pins. */
+    setStoryPackageDisabled(packageId: string, disabled: boolean): Promise<{
+        packageId: string;
+        disabled: boolean;
+    }>;
+    /** The pre-launch checklist for a world: every reason it would refuse to
+     *  run, gathered before you try.
+     *
+     *  OWNER TOKEN ONLY — there is no `/admin` mirror for this route, so an
+     *  unattended backend cannot call it. That is not an oversight to work
+     *  around: `getWorldOverview` carries `ready` and `blockers` and IS
+     *  mirrored, so a machine has the readiness answer it needs. */
+    preflightWorld(environmentId: string): Promise<unknown>;
     /** Publish the next world revision. Existing world INSTANCES keep the
      *  revision they were created on — a published change reaches new instances
      *  only, which is what keeps a running story from changing runtime or rules
@@ -1012,8 +1094,30 @@ export declare class PouchyWorldClient {
         version?: 1 | 2;
     }): Promise<ApprovedScriptExportRow>;
     listApprovedExports(environmentId: string, worldInstanceId: string, draftId: string, editorialId: string): Promise<{
-        exports: unknown[];
+        exports: ApprovedScriptExportSummary[];
     }>;
+    /** Read ONE approved export, script included — the machine lane's read.
+     *
+     *  This is the call an unattended backend makes. With `adminKey` set it goes
+     *  to the `/admin` mirror and needs no browser anywhere in your deployment;
+     *  with an `adminToken` it goes to the owner plane. Same mechanism as
+     *  `getProgress` and `getTurn`.
+     *
+     *  Every field it needs is in the `world.script_approved` webhook you
+     *  received: `exportId` at the top level, and `environmentId`,
+     *  `worldInstanceId`, `evidenceDraftId` and `editorialDraftId` inside
+     *  `lineage`. So the webhook → read loop closes without a person in it.
+     *
+     *  It READS. It does not create, approve or re-approve: minting an export is
+     *  a reviewer signing off on a specific text, and that stays on the owner
+     *  plane with a human behind it. What comes back cannot change — `exportId`
+     *  is the content digest of the body it returns.
+     *
+     *  Narrow `content.contractVersion` before reading version-specific fields.
+     *  A miss of any kind — wrong instance, wrong draft, wrong id — is one 404;
+     *  they are not told apart, so a caller cannot map an id space by reading
+     *  refusals. */
+    getApprovedExport(environmentId: string, worldInstanceId: string, draftId: string, editorialId: string, exportId: string): Promise<ApprovedScriptExportRow>;
     /** The next Story Package as a CANDIDATE — validated, and returned rather
      *  than published. Publishing it is a separate act by a person, through
      *  `createStoryPackage`. Only evidence-origin material becomes canon.

package/dist/index.js

@@ -23,7 +23,7 @@ import { createHash, createHmac, randomUUID } from 'node:crypto';
  *  a project is running — which is exactly the field you reach for when a
  *  customer's integration behaves like an older SDK than they say they have.
  *  It sat at '0.1.0' for eight releases before anything compared the two. */
-export const WORLD_SDK_VERSION = '0.18.0';
+export const WORLD_SDK_VERSION = '0.20.0';
 export const DEFAULT_BASE_URL = 'https://pouchy.ai/v1';
 /** Read the commit turn id out of an envelope, so the signature covers the id
  *  the server will commit under. The payload half is base64url JSON; the
@@ -287,6 +287,65 @@ export class PouchyWorldClient {
     getWorld(environmentId) {
         return this.machine('GET', `/projects/${this.projectId}/environments/${environmentId}`, `/admin/environments/${environmentId}`);
     }
+    /** The world's readiness and operational aggregate — what the dashboard's
+     *  World Overview binds to.
+     *
+     *  This is the call to make BEFORE driving anything: `ready` plus the
+     *  `blockers` that explain a false, instance counts, and the delivery
+     *  queue's shape. It was reachable on both planes from the start and simply
+     *  had no method here, which meant the README's own credential table
+     *  promised an `adminKey` read the SDK could not perform. */
+    getWorldOverview(environmentId) {
+        return this.machine('GET', `/projects/${this.projectId}/environments/${environmentId}/overview`, `/admin/environments/${environmentId}/overview`);
+    }
+    /** What this world has cost, by month.
+     *
+     *  `months` is clamped server-side; omit it for the default window. */
+    getWorldCost(environmentId, months) {
+        const query = months === undefined ? '' : `?months=${encodeURIComponent(String(months))}`;
+        return this.machine('GET', `/projects/${this.projectId}/environments/${environmentId}/cost`, `/admin/environments/${environmentId}/cost`, undefined, query);
+    }
+    /** Every published revision of this world.
+     *
+     *  An instance is pinned to the revision it was created on, so this is how a
+     *  backend learns which definition a running story is actually playing. */
+    listWorldVersions(environmentId) {
+        return this.machine('GET', `/projects/${this.projectId}/environments/${environmentId}/versions`, `/admin/environments/${environmentId}/versions`);
+    }
+    /** Every published revision of a story package.
+     *
+     *  The response carries `hasUnsupported` / `unsupportedCount` as well as the
+     *  versions: a history this build cannot read whole is reported as PARTIAL
+     *  rather than passing its newest readable revision off as the newest one.
+     *  Check that flag before treating the last entry as current. */
+    listStoryPackageVersions(packageId) {
+        return this.machine('GET', `/projects/${this.projectId}/story-packages/${packageId}/versions`, `/admin/story-packages/${packageId}/versions`);
+    }
+    /** Stop (or restart) a world.
+     *
+     *  A disabled world refuses new sessions and new turns. Existing instances
+     *  are not deleted and their ledgers are untouched — this is a door being
+     *  shut, not history being erased, and passing `false` opens it again. */
+    setWorldDisabled(environmentId, disabled) {
+        return this.machine('POST', `/projects/${this.projectId}/environments/${environmentId}/disable`, `/admin/environments/${environmentId}/disable`, { disabled });
+    }
+    /** Stop (or restart) a story package.
+     *
+     *  Worlds already PINNED to one of its revisions keep running: an instance
+     *  holds its own revision for life. This stops new pins. */
+    setStoryPackageDisabled(packageId, disabled) {
+        return this.machine('POST', `/projects/${this.projectId}/story-packages/${packageId}/disable`, `/admin/story-packages/${packageId}/disable`, { disabled });
+    }
+    /** The pre-launch checklist for a world: every reason it would refuse to
+     *  run, gathered before you try.
+     *
+     *  OWNER TOKEN ONLY — there is no `/admin` mirror for this route, so an
+     *  unattended backend cannot call it. That is not an oversight to work
+     *  around: `getWorldOverview` carries `ready` and `blockers` and IS
+     *  mirrored, so a machine has the readiness answer it needs. */
+    preflightWorld(environmentId) {
+        return this.owner('GET', `/projects/${this.projectId}/environments/${environmentId}/preflight`);
+    }
     /** Publish the next world revision. Existing world INSTANCES keep the
      *  revision they were created on — a published change reaches new instances
      *  only, which is what keeps a running story from changing runtime or rules
@@ -475,6 +534,30 @@ export class PouchyWorldClient {
     listApprovedExports(environmentId, worldInstanceId, draftId, editorialId) {
         return this.owner('GET', `/projects/${this.projectId}/environments/${environmentId}/instances/${worldInstanceId}/script-drafts/${draftId}/editorial/${editorialId}/approved-export`);
     }
+    /** Read ONE approved export, script included — the machine lane's read.
+     *
+     *  This is the call an unattended backend makes. With `adminKey` set it goes
+     *  to the `/admin` mirror and needs no browser anywhere in your deployment;
+     *  with an `adminToken` it goes to the owner plane. Same mechanism as
+     *  `getProgress` and `getTurn`.
+     *
+     *  Every field it needs is in the `world.script_approved` webhook you
+     *  received: `exportId` at the top level, and `environmentId`,
+     *  `worldInstanceId`, `evidenceDraftId` and `editorialDraftId` inside
+     *  `lineage`. So the webhook → read loop closes without a person in it.
+     *
+     *  It READS. It does not create, approve or re-approve: minting an export is
+     *  a reviewer signing off on a specific text, and that stays on the owner
+     *  plane with a human behind it. What comes back cannot change — `exportId`
+     *  is the content digest of the body it returns.
+     *
+     *  Narrow `content.contractVersion` before reading version-specific fields.
+     *  A miss of any kind — wrong instance, wrong draft, wrong id — is one 404;
+     *  they are not told apart, so a caller cannot map an id space by reading
+     *  refusals. */
+    getApprovedExport(environmentId, worldInstanceId, draftId, editorialId, exportId) {
+        return this.read(`/projects/${this.projectId}/environments/${environmentId}/instances/${worldInstanceId}/script-drafts/${draftId}/editorial/${editorialId}/approved-export/${encodeURIComponent(exportId)}`, `/admin/environments/${environmentId}/instances/${worldInstanceId}/script-drafts/${draftId}/editorial/${editorialId}/approved-export/${encodeURIComponent(exportId)}`);
+    }
     /** The next Story Package as a CANDIDATE — validated, and returned rather
      *  than published. Publishing it is a separate act by a person, through
      *  `createStoryPackage`. Only evidence-origin material becomes canon.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@pouchy_ai/world-sdk",
-	"version": "0.18.0",
+	"version": "0.20.0",
 	"description": "Server-side TypeScript client for Pouchy World \u2014 story packages, world definitions, world sessions, coordinated turns, trusted events, replay verification and script drafts. Node only: it holds a project Secret Key and a source signing key, which never belong in a browser or a mobile app.",
 	"type": "module",
 	"license": "SEE LICENSE IN LICENSE",