@moku-labs/worker 0.9.0 → 0.9.1

package/dist/{cli-Cs3R3Jhr.mjs → cli--EPl98vG.mjs}

@@ -2090,12 +2090,12 @@ const runDev = async (ctx, opts, deps) => {
 //#endregion
 //#region src/plugins/deploy/infra/plan.ts
 /**
-* Decide whether a single declared resource already exists in the account, recovering its id
-* (kv/d1) when it does. Durable Objects are config-only — they ship with the Worker (`wrangler
-* deploy` + the auto-derived DO migration create the namespace), never provisioned via the API — so
-* they are treated as already EXISTING, and the plan never re-offers to "create" them each deploy.
+* Decide whether a single API-provisioned resource already exists in the account, recovering its id
+* (kv/d1) when it does. Durable Objects are NOT handled here — they ship with the Worker (`wrangler
+* deploy` + the auto-derived DO migration create the namespace), are never provisioned via the API,
+* and are partitioned into the plan's `ships` bucket by {@link planInfra} before this is ever called.
 *
-* @param resource - The declared resource descriptor.
+* @param resource - The declared (provisionable) resource descriptor.
 * @param existing - The indexed set of resources already in the account.
 * @returns Whether it exists, plus the captured id for kv/d1.
 * @example
@@ -2121,7 +2121,6 @@ const checkExisting = (resource, existing) => {
 		}
 		case "r2": return { exists: existing.r2.has(resource.name) };
 		case "queue": return { exists: existing.queue.has(resource.name) };
-		case "do": return { exists: true };
 	}
 };
 /**
@@ -2130,7 +2129,7 @@ const checkExisting = (resource, existing) => {
 *
 * @param ctx - The deploy plugin context (env + emit).
 * @param manifest - The assembled (or caller-supplied) deploy manifest.
-* @returns The infra plan: existing (with ids) vs missing resources.
+* @returns The infra plan: existing (with ids) vs missing vs ships-with-Worker (Durable Objects).
 * @throws {Error} When the token is absent/invalid or a Cloudflare listing fails.
 * @example
 * ```ts
@@ -2149,7 +2148,12 @@ const planInfra = async (ctx, manifest) => {
 	const existing = await listExisting(token, account.id, kinds);
 	const exists = [];
 	const missing = [];
+	const ships = [];
 	for (const resource of manifest.resources) {
+		if (resource.kind === "do") {
+			ships.push(resource);
+			continue;
+		}
 		const check = checkExisting(resource, existing);
 		if (check.exists) exists.push(check.id === void 0 ? { resource } : {
 			resource,
@@ -2160,13 +2164,15 @@ const planInfra = async (ctx, manifest) => {
 	ctx.emit("provision:plan", {
 		exists: exists.length,
 		missing: missing.length,
+		ships: ships.length,
 		account: account.name
 	});
 	return {
 		account: account.name,
 		accountId: account.id,
 		exists,
-		missing
+		missing,
+		ships
 	};
 };
 //#endregion
@@ -2197,6 +2203,12 @@ const resourceName = (resource) => resource.kind === "do" ? resource.className :
 */
 const cell = (kind, name) => `${kind.padEnd(6)}${name}`;
 /**
+* Row tag for a Durable Object — it ships with the Worker (`wrangler deploy` creates the namespace),
+* so it is NEVER labelled `(exists)` (the planner never queried the account for it). Shared by the
+* plan and provision-result panels so the two always read the same.
+*/
+const SHIPS_WITH_WORKER = "(ships with worker)";
+/**
 * ANSI SGR matcher — built from `String.fromCharCode(27)` (the ESC byte) so no control character
 * appears in a regex literal (which both linters reject).
 */
@@ -2257,10 +2269,11 @@ const wrapText = (text, width) => {
 /**
 * Render the infra preflight plan as a branded panel: a dim summary line (counts + account) then one
 * row per declared resource — a pink `+` for those to create, a dim `~ (exists)` for those already
-* present. When nothing needs creating it still renders, so the user sees the full picture.
+* present, and a dim `~ (ships with worker)` for Durable Objects (created by `wrangler deploy`, never
+* pre-provisioned). When nothing needs creating it still renders, so the user sees the full picture.
 *
 * @param ui - The branded console to render through.
-* @param plan - The infra plan (existing vs missing) from checkInfra()/planInfra().
+* @param plan - The infra plan (existing vs missing vs ships-with-Worker) from checkInfra()/planInfra().
 * @example
 * ```ts
 * renderPlan(ui, await planInfra(ctx, manifest));
@@ -2268,22 +2281,27 @@ const wrapText = (text, width) => {
 */
 const renderPlan = (ui, plan) => {
 	const { palette } = ui;
-	const summary = palette.dim(`${String(plan.missing.length)} to create · ${String(plan.exists.length)} exist · ${plan.account}`);
-	const existsRows = plan.exists.map((ref) => `${palette.dim("~")} ${cell(ref.resource.kind, resourceName(ref.resource))} ${palette.dim("(exists)")}`);
+	const counts = [`${String(plan.missing.length)} to create`, `${String(plan.exists.length)} exist`];
+	if (plan.ships.length > 0) counts.push(`${String(plan.ships.length)} with worker`);
+	const summary = palette.dim(`${counts.join(" · ")} · ${plan.account}`);
 	const createRows = plan.missing.map((resource) => `${palette.pink("+")} ${cell(resource.kind, resourceName(resource))}`);
+	const existsRows = plan.exists.map((ref) => `${palette.dim("~")} ${cell(ref.resource.kind, resourceName(ref.resource))} ${palette.dim("(exists)")}`);
+	const shipsRows = plan.ships.map((resource) => `${palette.dim("~")} ${cell(resource.kind, resourceName(resource))} ${palette.dim(SHIPS_WITH_WORKER)}`);
 	ui.heading("Infra plan");
 	ui.box([
 		summary,
 		"",
 		...createRows,
-		...existsRows
+		...existsRows,
+		...shipsRows
 	]);
 };
 /**
 * Render the provision result as a branded panel — a green `✓` per created resource, a dim `~` per
-* skipped, a red `✗` per failure, then a summary line (failed count red when non-zero) — followed,
-* when anything failed, by a detail block printing each failure's FULL reason (ANSI-stripped and
-* word-wrapped) so it is actually readable instead of truncated inside the box.
+* skipped, a dim `~ (ships with worker)` per Durable Object, a red `✗` per failure, then a summary
+* line (failed count red when non-zero) — followed, when anything failed, by a detail block printing
+* each failure's FULL reason (ANSI-stripped and word-wrapped) so it is actually readable instead of
+* truncated inside the box.
 *
 * @param ui - The branded console to render through.
 * @param result - The provision result from provisionInfra()/the deploy pipeline.
@@ -2296,13 +2314,17 @@ const renderProvisionResult = (ui, result) => {
 	const { palette } = ui;
 	const createdRows = result.created.map((ref) => `${palette.green("✓")} ${cell(ref.resource.kind, resourceName(ref.resource))}`);
 	const skippedRows = result.skipped.map((ref) => `${palette.dim("~")} ${cell(ref.resource.kind, resourceName(ref.resource))} ${palette.dim("(exists)")}`);
+	const bundledRows = result.bundled.map((resource) => `${palette.dim("~")} ${cell(resource.kind, resourceName(resource))} ${palette.dim(SHIPS_WITH_WORKER)}`);
 	const failedRows = result.failed.map((failure) => `${palette.red("✗")} ${cell(failure.resource.kind, resourceName(failure.resource))}`);
 	const failedCount = result.failed.length > 0 ? palette.red(`${String(result.failed.length)} failed`) : "0 failed";
-	const summary = `${String(result.created.length)} created · ${String(result.skipped.length)} exist · ${failedCount}`;
+	const counts = [`${String(result.created.length)} created`, `${String(result.skipped.length)} exist`];
+	if (result.bundled.length > 0) counts.push(`${String(result.bundled.length)} with worker`);
+	const summary = `${counts.join(" · ")} · ${failedCount}`;
 	ui.heading("Provisioned");
 	ui.box([
 		...createdRows,
 		...skippedRows,
+		...bundledRows,
 		...failedRows,
 		"",
 		summary
@@ -2345,16 +2367,19 @@ const formatDuration = (ms) => {
 * @param summary.stage - The target stage the worker deployed to.
 * @param summary.created - How many resources were created this run.
 * @param summary.exists - How many resources already existed (skipped).
+* @param summary.bundled - How many Durable Objects shipped with the Worker.
 * @param summary.failed - How many resources failed to provision.
 * @param summary.elapsedMs - The wall-clock deploy duration in milliseconds.
 * @example
 * ```ts
-* renderDeploySummary(ui, { url, stage: "production", created: 0, exists: 5, failed: 0, elapsedMs: 4234 });
+* renderDeploySummary(ui, { url, stage: "production", created: 0, exists: 5, bundled: 1, failed: 0, elapsedMs: 4234 });
 * ```
 */
 const renderDeploySummary = (ui, summary) => {
 	const { palette } = ui;
-	const tally = `${String(summary.exists)} exist · ${String(summary.created)} created`;
+	const parts = [`${String(summary.exists)} exist`, `${String(summary.created)} created`];
+	if (summary.bundled > 0) parts.push(`${String(summary.bundled)} with worker`);
+	const tally = parts.join(" · ");
 	const failedLabel = palette.red(`${String(summary.failed)} failed`);
 	const resources = summary.failed > 0 ? `${tally} · ${failedLabel}` : tally;
 	ui.heading("Deployed");
@@ -2986,32 +3011,25 @@ const assembleManifest = (ctx, stage) => {
 	};
 };
 /**
-* Act on an infra plan: skip the resources that already exist (reusing their ids), create the
-* missing ones (capturing each new id), and announce each via provision:skip / :resource. Resilient
-* — a single resource that fails to create is CAPTURED in `failed` (not thrown), so one bad resource
-* (e.g. an invalid bucket name) never aborts the whole run and the caller can report a clear result.
+* Create the still-missing resources one at a time: provision each, fold its captured id (kv/d1) into
+* the shared `ids` map, and announce it via provision:resource. Resilient — a single failure is
+* CAPTURED (not thrown), so one bad resource never aborts the rest. Extracted from {@link applyPlan}
+* so that orchestrator stays flat (skip existing, skip DOs, create missing).
 *
 * @param ctx - The deploy plugin context.
-* @param plan - The infra plan from planInfra (existing vs missing).
+* @param missing - The resources the plan flagged as not-yet-existing.
 * @param ci - Whether provisioning runs non-interactively (forwarded to each provider).
-* @returns The provisioning result: created, skipped, failed, and the merged binding → id map.
+* @param ids - The binding → Cloudflare id map, mutated in place with each created kv/d1 id.
+* @returns The created refs and any captured per-resource failures.
 * @example
 * ```ts
-* const { created, failed } = await applyPlan(ctx, plan, false);
+* const { created, failed } = await provisionMissing(ctx, plan.missing, false, ids);
 * ```
 */
-const applyPlan = async (ctx, plan, ci) => {
-	const ids = {};
-	for (const ref of plan.exists) {
-		if (ref.id !== void 0 && (ref.resource.kind === "kv" || ref.resource.kind === "d1")) ids[ref.resource.binding] = ref.id;
-		ctx.emit("provision:skip", {
-			kind: ref.resource.kind,
-			name: resourceName(ref.resource)
-		});
-	}
+const provisionMissing = async (ctx, missing, ci, ids) => {
 	const created = [];
 	const failed = [];
-	for (const resource of plan.missing) try {
+	for (const resource of missing) try {
 		const { id } = await provisionResource(resource, ci);
 		if (id !== void 0 && (resource.kind === "kv" || resource.kind === "d1")) ids[resource.binding] = id;
 		created.push(id === void 0 ? { resource } : {
@@ -3028,9 +3046,45 @@ const applyPlan = async (ctx, plan, ci) => {
 			error: error instanceof Error ? error.message : String(error)
 		});
 	}
+	return {
+		created,
+		failed
+	};
+};
+/**
+* Act on an infra plan: skip the resources that already exist (reusing their ids), skip the Durable
+* Objects that ship with the Worker, create the missing ones (capturing each new id), and announce
+* each via provision:skip / :resource. Resilient — a single resource that fails to create is CAPTURED
+* in `failed` (not thrown), so one bad resource (e.g. an invalid bucket name) never aborts the whole
+* run and the caller can report a clear result.
+*
+* @param ctx - The deploy plugin context.
+* @param plan - The infra plan from planInfra (existing vs missing vs ships-with-Worker).
+* @param ci - Whether provisioning runs non-interactively (forwarded to each provider).
+* @returns The provisioning result: created, skipped, bundled, failed, and the merged binding → id map.
+* @example
+* ```ts
+* const { created, failed } = await applyPlan(ctx, plan, false);
+* ```
+*/
+const applyPlan = async (ctx, plan, ci) => {
+	const ids = {};
+	for (const ref of plan.exists) {
+		if (ref.id !== void 0 && (ref.resource.kind === "kv" || ref.resource.kind === "d1")) ids[ref.resource.binding] = ref.id;
+		ctx.emit("provision:skip", {
+			kind: ref.resource.kind,
+			name: resourceName(ref.resource)
+		});
+	}
+	for (const resource of plan.ships) ctx.emit("provision:skip", {
+		kind: resource.kind,
+		name: resourceName(resource)
+	});
+	const { created, failed } = await provisionMissing(ctx, plan.missing, ci, ids);
 	return {
 		created,
 		skipped: plan.exists,
+		bundled: plan.ships,
 		failed,
 		ids
 	};
@@ -3464,6 +3518,7 @@ const createDeployApi = (ctx) => ({
 		const resources = {
 			created: provisioned.created.length,
 			exists: provisioned.skipped.length,
+			bundled: provisioned.bundled.length,
 			failed: provisioned.failed.length
 		};
 		renderDeploySummary(createBrandConsole(), {

package/dist/{cli-CfgYgnzW.cjs → cli-imQGo0tc.cjs}

@@ -2113,12 +2113,12 @@ const runDev = async (ctx, opts, deps) => {
 //#endregion
 //#region src/plugins/deploy/infra/plan.ts
 /**
-* Decide whether a single declared resource already exists in the account, recovering its id
-* (kv/d1) when it does. Durable Objects are config-only — they ship with the Worker (`wrangler
-* deploy` + the auto-derived DO migration create the namespace), never provisioned via the API — so
-* they are treated as already EXISTING, and the plan never re-offers to "create" them each deploy.
+* Decide whether a single API-provisioned resource already exists in the account, recovering its id
+* (kv/d1) when it does. Durable Objects are NOT handled here — they ship with the Worker (`wrangler
+* deploy` + the auto-derived DO migration create the namespace), are never provisioned via the API,
+* and are partitioned into the plan's `ships` bucket by {@link planInfra} before this is ever called.
 *
-* @param resource - The declared resource descriptor.
+* @param resource - The declared (provisionable) resource descriptor.
 * @param existing - The indexed set of resources already in the account.
 * @returns Whether it exists, plus the captured id for kv/d1.
 * @example
@@ -2144,7 +2144,6 @@ const checkExisting = (resource, existing) => {
 		}
 		case "r2": return { exists: existing.r2.has(resource.name) };
 		case "queue": return { exists: existing.queue.has(resource.name) };
-		case "do": return { exists: true };
 	}
 };
 /**
@@ -2153,7 +2152,7 @@ const checkExisting = (resource, existing) => {
 *
 * @param ctx - The deploy plugin context (env + emit).
 * @param manifest - The assembled (or caller-supplied) deploy manifest.
-* @returns The infra plan: existing (with ids) vs missing resources.
+* @returns The infra plan: existing (with ids) vs missing vs ships-with-Worker (Durable Objects).
 * @throws {Error} When the token is absent/invalid or a Cloudflare listing fails.
 * @example
 * ```ts
@@ -2172,7 +2171,12 @@ const planInfra = async (ctx, manifest) => {
 	const existing = await listExisting(token, account.id, kinds);
 	const exists = [];
 	const missing = [];
+	const ships = [];
 	for (const resource of manifest.resources) {
+		if (resource.kind === "do") {
+			ships.push(resource);
+			continue;
+		}
 		const check = checkExisting(resource, existing);
 		if (check.exists) exists.push(check.id === void 0 ? { resource } : {
 			resource,
@@ -2183,13 +2187,15 @@ const planInfra = async (ctx, manifest) => {
 	ctx.emit("provision:plan", {
 		exists: exists.length,
 		missing: missing.length,
+		ships: ships.length,
 		account: account.name
 	});
 	return {
 		account: account.name,
 		accountId: account.id,
 		exists,
-		missing
+		missing,
+		ships
 	};
 };
 //#endregion
@@ -2220,6 +2226,12 @@ const resourceName = (resource) => resource.kind === "do" ? resource.className :
 */
 const cell = (kind, name) => `${kind.padEnd(6)}${name}`;
 /**
+* Row tag for a Durable Object — it ships with the Worker (`wrangler deploy` creates the namespace),
+* so it is NEVER labelled `(exists)` (the planner never queried the account for it). Shared by the
+* plan and provision-result panels so the two always read the same.
+*/
+const SHIPS_WITH_WORKER = "(ships with worker)";
+/**
 * ANSI SGR matcher — built from `String.fromCharCode(27)` (the ESC byte) so no control character
 * appears in a regex literal (which both linters reject).
 */
@@ -2280,10 +2292,11 @@ const wrapText = (text, width) => {
 /**
 * Render the infra preflight plan as a branded panel: a dim summary line (counts + account) then one
 * row per declared resource — a pink `+` for those to create, a dim `~ (exists)` for those already
-* present. When nothing needs creating it still renders, so the user sees the full picture.
+* present, and a dim `~ (ships with worker)` for Durable Objects (created by `wrangler deploy`, never
+* pre-provisioned). When nothing needs creating it still renders, so the user sees the full picture.
 *
 * @param ui - The branded console to render through.
-* @param plan - The infra plan (existing vs missing) from checkInfra()/planInfra().
+* @param plan - The infra plan (existing vs missing vs ships-with-Worker) from checkInfra()/planInfra().
 * @example
 * ```ts
 * renderPlan(ui, await planInfra(ctx, manifest));
@@ -2291,22 +2304,27 @@ const wrapText = (text, width) => {
 */
 const renderPlan = (ui, plan) => {
 	const { palette } = ui;
-	const summary = palette.dim(`${String(plan.missing.length)} to create · ${String(plan.exists.length)} exist · ${plan.account}`);
-	const existsRows = plan.exists.map((ref) => `${palette.dim("~")} ${cell(ref.resource.kind, resourceName(ref.resource))} ${palette.dim("(exists)")}`);
+	const counts = [`${String(plan.missing.length)} to create`, `${String(plan.exists.length)} exist`];
+	if (plan.ships.length > 0) counts.push(`${String(plan.ships.length)} with worker`);
+	const summary = palette.dim(`${counts.join(" · ")} · ${plan.account}`);
 	const createRows = plan.missing.map((resource) => `${palette.pink("+")} ${cell(resource.kind, resourceName(resource))}`);
+	const existsRows = plan.exists.map((ref) => `${palette.dim("~")} ${cell(ref.resource.kind, resourceName(ref.resource))} ${palette.dim("(exists)")}`);
+	const shipsRows = plan.ships.map((resource) => `${palette.dim("~")} ${cell(resource.kind, resourceName(resource))} ${palette.dim(SHIPS_WITH_WORKER)}`);
 	ui.heading("Infra plan");
 	ui.box([
 		summary,
 		"",
 		...createRows,
-		...existsRows
+		...existsRows,
+		...shipsRows
 	]);
 };
 /**
 * Render the provision result as a branded panel — a green `✓` per created resource, a dim `~` per
-* skipped, a red `✗` per failure, then a summary line (failed count red when non-zero) — followed,
-* when anything failed, by a detail block printing each failure's FULL reason (ANSI-stripped and
-* word-wrapped) so it is actually readable instead of truncated inside the box.
+* skipped, a dim `~ (ships with worker)` per Durable Object, a red `✗` per failure, then a summary
+* line (failed count red when non-zero) — followed, when anything failed, by a detail block printing
+* each failure's FULL reason (ANSI-stripped and word-wrapped) so it is actually readable instead of
+* truncated inside the box.
 *
 * @param ui - The branded console to render through.
 * @param result - The provision result from provisionInfra()/the deploy pipeline.
@@ -2319,13 +2337,17 @@ const renderProvisionResult = (ui, result) => {
 	const { palette } = ui;
 	const createdRows = result.created.map((ref) => `${palette.green("✓")} ${cell(ref.resource.kind, resourceName(ref.resource))}`);
 	const skippedRows = result.skipped.map((ref) => `${palette.dim("~")} ${cell(ref.resource.kind, resourceName(ref.resource))} ${palette.dim("(exists)")}`);
+	const bundledRows = result.bundled.map((resource) => `${palette.dim("~")} ${cell(resource.kind, resourceName(resource))} ${palette.dim(SHIPS_WITH_WORKER)}`);
 	const failedRows = result.failed.map((failure) => `${palette.red("✗")} ${cell(failure.resource.kind, resourceName(failure.resource))}`);
 	const failedCount = result.failed.length > 0 ? palette.red(`${String(result.failed.length)} failed`) : "0 failed";
-	const summary = `${String(result.created.length)} created · ${String(result.skipped.length)} exist · ${failedCount}`;
+	const counts = [`${String(result.created.length)} created`, `${String(result.skipped.length)} exist`];
+	if (result.bundled.length > 0) counts.push(`${String(result.bundled.length)} with worker`);
+	const summary = `${counts.join(" · ")} · ${failedCount}`;
 	ui.heading("Provisioned");
 	ui.box([
 		...createdRows,
 		...skippedRows,
+		...bundledRows,
 		...failedRows,
 		"",
 		summary
@@ -2368,16 +2390,19 @@ const formatDuration = (ms) => {
 * @param summary.stage - The target stage the worker deployed to.
 * @param summary.created - How many resources were created this run.
 * @param summary.exists - How many resources already existed (skipped).
+* @param summary.bundled - How many Durable Objects shipped with the Worker.
 * @param summary.failed - How many resources failed to provision.
 * @param summary.elapsedMs - The wall-clock deploy duration in milliseconds.
 * @example
 * ```ts
-* renderDeploySummary(ui, { url, stage: "production", created: 0, exists: 5, failed: 0, elapsedMs: 4234 });
+* renderDeploySummary(ui, { url, stage: "production", created: 0, exists: 5, bundled: 1, failed: 0, elapsedMs: 4234 });
 * ```
 */
 const renderDeploySummary = (ui, summary) => {
 	const { palette } = ui;
-	const tally = `${String(summary.exists)} exist · ${String(summary.created)} created`;
+	const parts = [`${String(summary.exists)} exist`, `${String(summary.created)} created`];
+	if (summary.bundled > 0) parts.push(`${String(summary.bundled)} with worker`);
+	const tally = parts.join(" · ");
 	const failedLabel = palette.red(`${String(summary.failed)} failed`);
 	const resources = summary.failed > 0 ? `${tally} · ${failedLabel}` : tally;
 	ui.heading("Deployed");
@@ -3009,32 +3034,25 @@ const assembleManifest = (ctx, stage) => {
 	};
 };
 /**
-* Act on an infra plan: skip the resources that already exist (reusing their ids), create the
-* missing ones (capturing each new id), and announce each via provision:skip / :resource. Resilient
-* — a single resource that fails to create is CAPTURED in `failed` (not thrown), so one bad resource
-* (e.g. an invalid bucket name) never aborts the whole run and the caller can report a clear result.
+* Create the still-missing resources one at a time: provision each, fold its captured id (kv/d1) into
+* the shared `ids` map, and announce it via provision:resource. Resilient — a single failure is
+* CAPTURED (not thrown), so one bad resource never aborts the rest. Extracted from {@link applyPlan}
+* so that orchestrator stays flat (skip existing, skip DOs, create missing).
 *
 * @param ctx - The deploy plugin context.
-* @param plan - The infra plan from planInfra (existing vs missing).
+* @param missing - The resources the plan flagged as not-yet-existing.
 * @param ci - Whether provisioning runs non-interactively (forwarded to each provider).
-* @returns The provisioning result: created, skipped, failed, and the merged binding → id map.
+* @param ids - The binding → Cloudflare id map, mutated in place with each created kv/d1 id.
+* @returns The created refs and any captured per-resource failures.
 * @example
 * ```ts
-* const { created, failed } = await applyPlan(ctx, plan, false);
+* const { created, failed } = await provisionMissing(ctx, plan.missing, false, ids);
 * ```
 */
-const applyPlan = async (ctx, plan, ci) => {
-	const ids = {};
-	for (const ref of plan.exists) {
-		if (ref.id !== void 0 && (ref.resource.kind === "kv" || ref.resource.kind === "d1")) ids[ref.resource.binding] = ref.id;
-		ctx.emit("provision:skip", {
-			kind: ref.resource.kind,
-			name: resourceName(ref.resource)
-		});
-	}
+const provisionMissing = async (ctx, missing, ci, ids) => {
 	const created = [];
 	const failed = [];
-	for (const resource of plan.missing) try {
+	for (const resource of missing) try {
 		const { id } = await provisionResource(resource, ci);
 		if (id !== void 0 && (resource.kind === "kv" || resource.kind === "d1")) ids[resource.binding] = id;
 		created.push(id === void 0 ? { resource } : {
@@ -3051,9 +3069,45 @@ const applyPlan = async (ctx, plan, ci) => {
 			error: error instanceof Error ? error.message : String(error)
 		});
 	}
+	return {
+		created,
+		failed
+	};
+};
+/**
+* Act on an infra plan: skip the resources that already exist (reusing their ids), skip the Durable
+* Objects that ship with the Worker, create the missing ones (capturing each new id), and announce
+* each via provision:skip / :resource. Resilient — a single resource that fails to create is CAPTURED
+* in `failed` (not thrown), so one bad resource (e.g. an invalid bucket name) never aborts the whole
+* run and the caller can report a clear result.
+*
+* @param ctx - The deploy plugin context.
+* @param plan - The infra plan from planInfra (existing vs missing vs ships-with-Worker).
+* @param ci - Whether provisioning runs non-interactively (forwarded to each provider).
+* @returns The provisioning result: created, skipped, bundled, failed, and the merged binding → id map.
+* @example
+* ```ts
+* const { created, failed } = await applyPlan(ctx, plan, false);
+* ```
+*/
+const applyPlan = async (ctx, plan, ci) => {
+	const ids = {};
+	for (const ref of plan.exists) {
+		if (ref.id !== void 0 && (ref.resource.kind === "kv" || ref.resource.kind === "d1")) ids[ref.resource.binding] = ref.id;
+		ctx.emit("provision:skip", {
+			kind: ref.resource.kind,
+			name: resourceName(ref.resource)
+		});
+	}
+	for (const resource of plan.ships) ctx.emit("provision:skip", {
+		kind: resource.kind,
+		name: resourceName(resource)
+	});
+	const { created, failed } = await provisionMissing(ctx, plan.missing, ci, ids);
 	return {
 		created,
 		skipped: plan.exists,
+		bundled: plan.ships,
 		failed,
 		ids
 	};
@@ -3487,6 +3541,7 @@ const createDeployApi = (ctx) => ({
 		const resources = {
 			created: provisioned.created.length,
 			exists: provisioned.skipped.length,
+			bundled: provisioned.bundled.length,
 			failed: provisioned.failed.length
 		};
 		renderDeploySummary((0, _moku_labs_common_cli.createBrandConsole)(), {

package/dist/cli.cjs

@@ -1,4 +1,4 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_cli = require("./cli-CfgYgnzW.cjs");
+const require_cli = require("./cli-imQGo0tc.cjs");
 exports.cliPlugin = require_cli.cliPlugin;
 exports.deployPlugin = require_cli.deployPlugin;

package/dist/cli.d.cts

@@ -1,2 +1,2 @@
-import { a as ResourceManifest, i as ExternalManifest, n as cliPlugin, t as deployPlugin } from "./index-Cb3vzZte.cjs";
+import { a as ResourceManifest, i as ExternalManifest, n as cliPlugin, t as deployPlugin } from "./index-CWxQr2Q3.cjs";
 export { type ExternalManifest, type ResourceManifest, cliPlugin, deployPlugin };

package/dist/cli.d.mts

@@ -1,2 +1,2 @@
-import { a as ResourceManifest, i as ExternalManifest, n as cliPlugin, t as deployPlugin } from "./index-Cb3vzZte.mjs";
+import { a as ResourceManifest, i as ExternalManifest, n as cliPlugin, t as deployPlugin } from "./index-CWxQr2Q3.mjs";
 export { type ExternalManifest, type ResourceManifest, cliPlugin, deployPlugin };

package/dist/cli.mjs

@@ -1,2 +1,2 @@
-import { n as deployPlugin, t as cliPlugin } from "./cli-Cs3R3Jhr.mjs";
+import { n as deployPlugin, t as cliPlugin } from "./cli--EPl98vG.mjs";
 export { cliPlugin, deployPlugin };

package/dist/{index-Cb3vzZte.d.cts → index-CWxQr2Q3.d.cts}

@@ -36,6 +36,7 @@ type WorkerEvents = {
   "provision:plan": {
     exists: number;
     missing: number;
+    ships: number;
     account: string;
   };
   "provision:skip": {
@@ -246,13 +247,18 @@ type ProvisionedRef = {
 };
 /**
  * Read-only infra preflight result: which declared resources already exist in the Cloudflare
- * account versus which are still missing and must be created. Produced by `checkInfra()`.
+ * account, which are still missing and must be created, and which ship with the Worker. Produced by
+ * `checkInfra()`. Durable Objects are neither "exists" nor "missing" — the planner never queries the
+ * account for them and never API-provisions them; they are created by `wrangler deploy` (the
+ * auto-derived DO migration), so they get their own `ships` bucket instead of masquerading as
+ * already-existing.
  */
 type InfraPlan = {
   /** Resolved account display name (or id when the name is unknown). */account: string; /** Resolved Cloudflare account id used for the existence checks. */
-  accountId: string; /** Declared resources that already exist (with their captured ids where applicable). */
+  accountId: string; /** Declared resources the account listing confirmed already exist (with captured ids where applicable). */
   exists: ProvisionedRef[]; /** Declared resources that do not yet exist and must be created. */
-  missing: ResourceManifest[];
+  missing: ResourceManifest[]; /** Durable Objects that ship with the Worker — created by `wrangler deploy`, never API-provisioned. */
+  ships: ResourceManifest[];
 };
 /**
  * A resource that failed to provision, with the (branded) error message captured so the guided flow
@@ -264,13 +270,15 @@ type ProvisionFailure = {
 };
 /**
  * Outcome of acting on an {@link InfraPlan}: the resources just created, those skipped because they
- * already existed, those that FAILED to create, and the merged id map (binding → Cloudflare id) for
- * the config writer. Provisioning is resilient — a single resource failure is captured here, not
- * thrown, so the guided flow can report a clear per-resource result.
+ * already existed, those that ship with the Worker (Durable Objects — not created here), those that
+ * FAILED to create, and the merged id map (binding → Cloudflare id) for the config writer.
+ * Provisioning is resilient — a single resource failure is captured here, not thrown, so the guided
+ * flow can report a clear per-resource result.
  */
 type ProvisionResult = {
   /** Resources created during this run. */created: ProvisionedRef[]; /** Resources skipped because they already existed. */
-  skipped: ProvisionedRef[]; /** Resources that failed to create (captured, not thrown). */
+  skipped: ProvisionedRef[]; /** Durable Objects that ship with the Worker — not created at the provision step (`wrangler deploy` does). */
+  bundled: ResourceManifest[]; /** Resources that failed to create (captured, not thrown). */
   failed: ProvisionFailure[]; /** Merged binding → Cloudflare id map (existing + created) for writeWranglerConfig. */
   ids: Record<string, string>;
 };
@@ -289,10 +297,11 @@ type DeployReport = {
   /** True only when the worker is live and every requested post-step (migration, seed) succeeded. */ok: boolean; /** Coarse outcome: "deployed" (live + post-steps ok), "aborted" (a gate declined / auth not set up), "failed" (a step errored). */
   status: "deployed" | "aborted" | "failed"; /** The resolved deploy stage (resource-name suffix; "production" is bare). */
   stage: string; /** The live worker URL once `wrangler deploy` succeeded — set even if a later migration/seed failed. */
-  url?: string; /** Provisioning tally: resources created, already-existing, and failed to create. */
+  url?: string; /** Provisioning tally: resources created, already-existing, shipped-with-the-Worker (DOs), and failed to create. */
   resources?: {
     created: number;
     exists: number;
+    bundled: number;
     failed: number;
   }; /** Remote D1 migration outcome — "skipped" (not requested), "applied", or "failed". */
   migration: "skipped" | "applied" | "failed"; /** Remote seed outcome — "skipped" (not requested), "applied", or "failed". */

package/dist/{index-Cb3vzZte.d.mts → index-CWxQr2Q3.d.mts}

@@ -36,6 +36,7 @@ type WorkerEvents = {
   "provision:plan": {
     exists: number;
     missing: number;
+    ships: number;
     account: string;
   };
   "provision:skip": {
@@ -246,13 +247,18 @@ type ProvisionedRef = {
 };
 /**
  * Read-only infra preflight result: which declared resources already exist in the Cloudflare
- * account versus which are still missing and must be created. Produced by `checkInfra()`.
+ * account, which are still missing and must be created, and which ship with the Worker. Produced by
+ * `checkInfra()`. Durable Objects are neither "exists" nor "missing" — the planner never queries the
+ * account for them and never API-provisions them; they are created by `wrangler deploy` (the
+ * auto-derived DO migration), so they get their own `ships` bucket instead of masquerading as
+ * already-existing.
  */
 type InfraPlan = {
   /** Resolved account display name (or id when the name is unknown). */account: string; /** Resolved Cloudflare account id used for the existence checks. */
-  accountId: string; /** Declared resources that already exist (with their captured ids where applicable). */
+  accountId: string; /** Declared resources the account listing confirmed already exist (with captured ids where applicable). */
   exists: ProvisionedRef[]; /** Declared resources that do not yet exist and must be created. */
-  missing: ResourceManifest[];
+  missing: ResourceManifest[]; /** Durable Objects that ship with the Worker — created by `wrangler deploy`, never API-provisioned. */
+  ships: ResourceManifest[];
 };
 /**
  * A resource that failed to provision, with the (branded) error message captured so the guided flow
@@ -264,13 +270,15 @@ type ProvisionFailure = {
 };
 /**
  * Outcome of acting on an {@link InfraPlan}: the resources just created, those skipped because they
- * already existed, those that FAILED to create, and the merged id map (binding → Cloudflare id) for
- * the config writer. Provisioning is resilient — a single resource failure is captured here, not
- * thrown, so the guided flow can report a clear per-resource result.
+ * already existed, those that ship with the Worker (Durable Objects — not created here), those that
+ * FAILED to create, and the merged id map (binding → Cloudflare id) for the config writer.
+ * Provisioning is resilient — a single resource failure is captured here, not thrown, so the guided
+ * flow can report a clear per-resource result.
  */
 type ProvisionResult = {
   /** Resources created during this run. */created: ProvisionedRef[]; /** Resources skipped because they already existed. */
-  skipped: ProvisionedRef[]; /** Resources that failed to create (captured, not thrown). */
+  skipped: ProvisionedRef[]; /** Durable Objects that ship with the Worker — not created at the provision step (`wrangler deploy` does). */
+  bundled: ResourceManifest[]; /** Resources that failed to create (captured, not thrown). */
   failed: ProvisionFailure[]; /** Merged binding → Cloudflare id map (existing + created) for writeWranglerConfig. */
   ids: Record<string, string>;
 };
@@ -289,10 +297,11 @@ type DeployReport = {
   /** True only when the worker is live and every requested post-step (migration, seed) succeeded. */ok: boolean; /** Coarse outcome: "deployed" (live + post-steps ok), "aborted" (a gate declined / auth not set up), "failed" (a step errored). */
   status: "deployed" | "aborted" | "failed"; /** The resolved deploy stage (resource-name suffix; "production" is bare). */
   stage: string; /** The live worker URL once `wrangler deploy` succeeded — set even if a later migration/seed failed. */
-  url?: string; /** Provisioning tally: resources created, already-existing, and failed to create. */
+  url?: string; /** Provisioning tally: resources created, already-existing, shipped-with-the-Worker (DOs), and failed to create. */
   resources?: {
     created: number;
     exists: number;
+    bundled: number;
     failed: number;
   }; /** Remote D1 migration outcome — "skipped" (not requested), "applied", or "failed". */
   migration: "skipped" | "applied" | "failed"; /** Remote seed outcome — "skipped" (not requested), "applied", or "failed". */

package/dist/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_cli = require("./cli-CfgYgnzW.cjs");
+const require_cli = require("./cli-imQGo0tc.cjs");
 let _moku_labs_common = require("@moku-labs/common");
 //#region src/env-provider.ts
 /**

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { a as ResourceManifest, c as WorkerEnv, i as ExternalManifest, l as WorkerEvents, n as cliPlugin, o as SeedConfig, r as DeployReport, s as WorkerConfig, t as deployPlugin, u as WorkerPluginCtx } from "./index-Cb3vzZte.cjs";
+import { a as ResourceManifest, c as WorkerEnv, i as ExternalManifest, l as WorkerEvents, n as cliPlugin, o as SeedConfig, r as DeployReport, s as WorkerConfig, t as deployPlugin, u as WorkerPluginCtx } from "./index-CWxQr2Q3.cjs";
 import { envPlugin, logPlugin } from "@moku-labs/common";
 import { PluginCtx, PluginCtx as PluginCtx$1, PluginInstance } from "@moku-labs/core";
 

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { a as ResourceManifest, c as WorkerEnv, i as ExternalManifest, l as WorkerEvents, n as cliPlugin, o as SeedConfig, r as DeployReport, s as WorkerConfig, t as deployPlugin, u as WorkerPluginCtx } from "./index-Cb3vzZte.mjs";
+import { a as ResourceManifest, c as WorkerEnv, i as ExternalManifest, l as WorkerEvents, n as cliPlugin, o as SeedConfig, r as DeployReport, s as WorkerConfig, t as deployPlugin, u as WorkerPluginCtx } from "./index-CWxQr2Q3.mjs";
 import { envPlugin, logPlugin } from "@moku-labs/common";
 import { PluginCtx, PluginCtx as PluginCtx$1, PluginInstance } from "@moku-labs/core";
 

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { a as kvPlugin, c as d1Plugin, d as createCore, f as createPlugin$1, i as queuesPlugin, l as bindingsPlugin, n as deployPlugin, o as durableObjectsPlugin, p as stagePlugin, r as storagePlugin, s as defineDurableObject, t as cliPlugin, u as coreConfig } from "./cli-Cs3R3Jhr.mjs";
+import { a as kvPlugin, c as d1Plugin, d as createCore, f as createPlugin$1, i as queuesPlugin, l as bindingsPlugin, n as deployPlugin, o as durableObjectsPlugin, p as stagePlugin, r as storagePlugin, s as defineDurableObject, t as cliPlugin, u as coreConfig } from "./cli--EPl98vG.mjs";
 import { envPlugin, logPlugin } from "@moku-labs/common";
 //#region src/env-provider.ts
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moku-labs/worker",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "Cloudflare Worker framework for Moku — Durable Objects, Queues, R2, D1, and KV plugins that compose with Moku Web.",
   "repository": {
     "type": "git",