playcademy 0.16.10 → 0.16.11

package/dist/cli.js

@@ -2965,7 +2965,7 @@ import { join as join13 } from "path";
 // package.json with { type: 'json' }
 var package_default2 = {
   name: "playcademy",
-  version: "0.16.9",
+  version: "0.16.10",
   type: "module",
   exports: {
     ".": {

package/dist/edge-play/src/entry/middleware.ts

@@ -8,6 +8,7 @@ import { cors } from 'hono/cors'
 
 import { PlaycademyClient, verifyGameToken } from '@playcademy/sdk/server'
 
+import { resolveRawSelfWorker, wrapSelfWorkerWithPathResolution } from '../lib/self-dispatch'
 import { populateProcessEnv, reconstructSecrets } from './setup'
 
 import type { Context, Hono } from 'hono'
@@ -47,6 +48,7 @@ export function registerEnvSetup(app: Hono<HonoEnv>, config: RuntimeConfig): voi
     app.use('*', async (c, next) => {
         populateProcessEnv(c.env)
         c.env.secrets = reconstructSecrets(c.env)
+        c.env.SELF = wrapSelfWorkerWithPathResolution(resolveRawSelfWorker(c.env), c.req.url)
         c.set('config', config)
         c.set('routeMetadata', config.__routeMetadata || [])
         await next()

package/dist/edge-play/src/lib/index.ts

@@ -1,2 +1,3 @@
 export * from './errors'
+export * from './self-dispatch'
 export * from './validation'

package/dist/edge-play/src/lib/self-dispatch.test.ts

@@ -0,0 +1,190 @@
+import { beforeEach, describe, expect, it, mock } from 'bun:test'
+
+import {
+    normalizeSelfFetchInput,
+    resolveRawSelfWorker,
+    wrapSelfWorkerWithPathResolution,
+} from './self-dispatch'
+
+import type { HonoEnv, SelfWorker } from '../types'
+
+describe('normalizeSelfFetchInput', () => {
+    const requestUrl = 'https://vocabulon-staging.playcademy.gg/api/admin/genai/sprint'
+
+    it('resolves root-relative paths to the current origin', () => {
+        const input = normalizeSelfFetchInput('/api/internal/process-batch', requestUrl)
+        expect(input).toBeInstanceOf(URL)
+        expect((input as URL).toString()).toBe(
+            'https://vocabulon-staging.playcademy.gg/api/internal/process-batch',
+        )
+    })
+
+    it('treats bare paths as root-relative', () => {
+        const input = normalizeSelfFetchInput('api/internal/process-batch', requestUrl)
+        expect(input).toBeInstanceOf(URL)
+        expect((input as URL).toString()).toBe(
+            'https://vocabulon-staging.playcademy.gg/api/internal/process-batch',
+        )
+    })
+
+    it('preserves absolute URL strings', () => {
+        const input = normalizeSelfFetchInput(
+            'https://vocabulon-staging.playcademy.gg/api/internal/process-batch',
+            requestUrl,
+        )
+        expect(input).toBeInstanceOf(URL)
+        expect((input as URL).toString()).toBe(
+            'https://vocabulon-staging.playcademy.gg/api/internal/process-batch',
+        )
+    })
+
+    it('preserves query and hash on normalized paths', () => {
+        const input = normalizeSelfFetchInput('/api/internal/process-batch?attempt=2#step', requestUrl)
+        expect(input).toBeInstanceOf(URL)
+        expect((input as URL).toString()).toBe(
+            'https://vocabulon-staging.playcademy.gg/api/internal/process-batch?attempt=2#step',
+        )
+    })
+
+    it('passes through URL objects unchanged', () => {
+        const url = new URL('https://vocabulon-staging.playcademy.gg/api/internal/process-batch')
+        const input = normalizeSelfFetchInput(url, requestUrl)
+        expect(input).toBe(url)
+    })
+
+    it('supports non-http absolute schemes', () => {
+        const input = normalizeSelfFetchInput('mailto:test@example.com', requestUrl)
+        expect(input).toBeInstanceOf(URL)
+        expect((input as URL).toString()).toBe('mailto:test@example.com')
+    })
+
+    it('does not allow protocol-relative input to escape origin', () => {
+        const input = normalizeSelfFetchInput('//evil.example.com/path', requestUrl)
+        expect(input).toBeInstanceOf(URL)
+        expect((input as URL).toString()).toBe('https://vocabulon-staging.playcademy.gg/evil.example.com/path')
+    })
+
+    it('passes through Request objects unchanged', () => {
+        const request = new Request('https://vocabulon-staging.playcademy.gg/api/internal/process-batch')
+        const input = normalizeSelfFetchInput(request, requestUrl)
+        expect(input).toBe(request)
+    })
+})
+
+describe('wrapSelfWorkerWithPathResolution', () => {
+    const requestUrl = 'https://vocabulon-staging.playcademy.gg/api/admin/genai/sprint'
+
+    it('normalizes string path inputs before delegating to raw self worker', async () => {
+        const calls: Array<{ input: RequestInfo | URL; init?: RequestInit }> = []
+        const raw: SelfWorker = {
+            fetch: (input, init) => {
+                calls.push({ input, init })
+                return Promise.resolve(new Response(null, { status: 202 }))
+            },
+        }
+
+        const self = wrapSelfWorkerWithPathResolution(raw, requestUrl)
+        const init = { method: 'POST' }
+        const response = await self.fetch('api/internal/process-batch', init)
+
+        expect(response.status).toBe(202)
+        expect(calls).toHaveLength(1)
+        expect(calls[0]?.input).toBeInstanceOf(URL)
+        expect((calls[0]?.input as URL).toString()).toBe(
+            'https://vocabulon-staging.playcademy.gg/api/internal/process-batch',
+        )
+        expect(calls[0]?.init).toEqual(init)
+    })
+
+    it('passes Request objects through to the raw self worker', async () => {
+        const calls: Array<{ input: RequestInfo | URL; init?: RequestInit }> = []
+        const raw: SelfWorker = {
+            fetch: (input, init) => {
+                calls.push({ input, init })
+                return Promise.resolve(new Response(null, { status: 204 }))
+            },
+        }
+        const self = wrapSelfWorkerWithPathResolution(raw, requestUrl)
+        const req = new Request('https://vocabulon-staging.playcademy.gg/api/internal/process-batch')
+
+        await self.fetch(req)
+
+        expect(calls).toHaveLength(1)
+        expect(calls[0]?.input).toBe(req)
+        expect(calls[0]?.init).toBeUndefined()
+    })
+})
+
+describe('resolveRawSelfWorker', () => {
+    beforeEach(() => {
+        mock.restore()
+    })
+
+    it('uses dispatch namespace binding when available', async () => {
+        const targetWorker: SelfWorker = {
+            fetch: () => Promise.resolve(new Response('ok')),
+        }
+
+        const env = {
+            __PLAYCADEMY_DISPATCH: {
+                get: (name: string) => {
+                    expect(name).toBe('staging-vocabulon')
+                    return targetWorker
+                },
+            },
+            __PLAYCADEMY_WORKER_NAME: 'staging-vocabulon',
+        } as unknown as HonoEnv['Bindings']
+
+        const resolved = resolveRawSelfWorker(env)
+        const response = await resolved.fetch('https://vocabulon-staging.playcademy.gg/api/internal/process')
+        expect(response.status).toBe(200)
+    })
+
+    it('falls back to global fetch when dispatch binding is unavailable', async () => {
+        const fetchMock = mock(() => Promise.resolve(new Response('fallback', { status: 204 })))
+        const originalFetch = globalThis.fetch
+        globalThis.fetch = fetchMock as unknown as typeof fetch
+
+        try {
+            const env = {} as HonoEnv['Bindings']
+            const resolved = resolveRawSelfWorker(env)
+            const response = await resolved.fetch(
+                'https://vocabulon-staging.playcademy.gg/api/internal/process',
+            )
+
+            expect(response.status).toBe(204)
+            expect(fetchMock).toHaveBeenCalledTimes(1)
+            const firstCall = fetchMock.mock.calls[0] as unknown[] | undefined
+            expect(firstCall).toBeDefined()
+            const arg = firstCall?.[0]
+            expect(arg).toBeInstanceOf(Request)
+        } finally {
+            globalThis.fetch = originalFetch
+        }
+    })
+
+    it('falls back to global fetch when worker name is missing', async () => {
+        const fetchMock = mock(() => Promise.resolve(new Response('fallback', { status: 206 })))
+        const originalFetch = globalThis.fetch
+        globalThis.fetch = fetchMock as unknown as typeof fetch
+
+        try {
+            const env = {
+                __PLAYCADEMY_DISPATCH: {
+                    get: () => {
+                        throw new Error('should not be called when worker name is missing')
+                    },
+                },
+            } as unknown as HonoEnv['Bindings']
+            const resolved = resolveRawSelfWorker(env)
+            const response = await resolved.fetch(
+                'https://vocabulon-staging.playcademy.gg/api/internal/process',
+            )
+
+            expect(response.status).toBe(206)
+            expect(fetchMock).toHaveBeenCalledTimes(1)
+        } finally {
+            globalThis.fetch = originalFetch
+        }
+    })
+})

package/dist/edge-play/src/lib/self-dispatch.ts

@@ -0,0 +1,41 @@
+import type { HonoEnv, SelfWorker } from '../types'
+
+function isAbsoluteUrl(value: string): boolean {
+    return /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(value)
+}
+
+export function normalizeSelfFetchInput(
+    input: RequestInfo | URL,
+    requestUrl: string,
+): RequestInfo | URL {
+    if (typeof input !== 'string') {
+        return input
+    }
+
+    if (isAbsoluteUrl(input)) {
+        return new URL(input)
+    }
+
+    const origin = new URL(requestUrl).origin
+    const sanitized = input.startsWith('//') ? `/${input.replace(/^\/+/, '')}` : input
+    const pathname = sanitized.startsWith('/') ? sanitized : `/${sanitized}`
+
+    return new URL(pathname, origin)
+}
+
+export function wrapSelfWorkerWithPathResolution(raw: SelfWorker, requestUrl: string): SelfWorker {
+    return {
+        fetch: (input, init) => raw.fetch(normalizeSelfFetchInput(input, requestUrl), init),
+    }
+}
+
+export function resolveRawSelfWorker(env: HonoEnv['Bindings']): SelfWorker {
+    const dispatchBinding = env.__PLAYCADEMY_DISPATCH
+    const workerName = env.__PLAYCADEMY_WORKER_NAME
+
+    if (dispatchBinding && workerName) {
+        return dispatchBinding.get(workerName)
+    }
+
+    return { fetch: (input, init) => fetch(new Request(input, init)) }
+}

package/dist/edge-play/src/types.ts

@@ -17,6 +17,21 @@ import type { RouteMetadata } from './entry/types'
  */
 export type AssetsFetcher = { fetch(request: Request): Promise<Response> }
 
+/**
+ * Internal self-dispatch worker fetcher.
+ * Exposed to games as env.SELF for background request chaining.
+ */
+export type SelfWorker = {
+    fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>
+}
+
+/**
+ * Dispatch namespace binding used to resolve the current worker.
+ */
+export type DispatchNamespaceBinding = {
+    get(name: string): SelfWorker
+}
+
 /**
  * Enabled integrations from playcademy.config.js
  */
@@ -60,6 +75,15 @@ export interface ServerEnv {
     /** R2 bucket binding (optional, Cloudflare-specific) */
     BUCKET?: R2Bucket
 
+    /** Self-dispatch API for internal loopback requests */
+    SELF?: SelfWorker
+
+    /** Internal dispatch namespace binding (hydrated to SELF by middleware) */
+    __PLAYCADEMY_DISPATCH?: DispatchNamespaceBinding
+
+    /** Internal worker name for self-resolution in dispatch namespace */
+    __PLAYCADEMY_WORKER_NAME?: string
+
     /** Allow dynamic secret bindings (secrets_KEY_NAME) */
     [key: string]: unknown
 }

package/dist/index.js

@@ -1357,7 +1357,7 @@ function ensureEnvironment(env) {
   }
   return getEnvironment();
 }
-function requireEnvironment(env, hostname) {
+function requireEnvironment(env, usage) {
   if (env) {
     return ensureEnvironment(env);
   }
@@ -1365,12 +1365,12 @@ function requireEnvironment(env, hostname) {
   if (envVar) {
     return ensureEnvironment(envVar);
   }
-  const example = hostname || "play.example.com";
+  const command = usage || "<command> [args]";
   logger.error("Missing required --env flag");
   logger.newLine();
   logger.admonition("tip", "Usage", [
-    `\`playcademy domain add ${example} --env production\``,
-    `\`playcademy domain add ${example} --env staging\``,
+    `\`playcademy ${command} --env production\``,
+    `\`playcademy ${command} --env staging\``,
     "",
     "Or set `PLAYCADEMY_ENV` in your environment."
   ]);
@@ -4016,7 +4016,7 @@ import { join as join12 } from "path";
 // package.json with { type: 'json' }
 var package_default2 = {
   name: "playcademy",
-  version: "0.16.9",
+  version: "0.16.10",
   type: "module",
   exports: {
     ".": {
@@ -11220,7 +11220,7 @@ var getStatusCommand = new Command13("status").description("Check your developer
 });
 
 // package.json
-var version2 = "0.16.9";
+var version2 = "0.16.10";
 
 // src/commands/dev/server.ts
 function setupCleanupHandlers(workspace, getServer) {
@@ -14627,7 +14627,7 @@ async function runDomainAdd(hostname, options) {
       process.exit(1);
     }
     const normalizedHostname = hostname.trim().toLowerCase();
-    requireEnvironment(options.env, normalizedHostname);
+    const environment = requireEnvironment(options.env, `domain add ${normalizedHostname}`);
     await requireConfigFile();
     const config = await loadConfig();
     const slug = getSlugFromConfig(config);
@@ -14643,7 +14643,7 @@ async function runDomainAdd(hostname, options) {
     displayDomainValidationRecords(domain, normalizedHostname);
     logger.admonition("tip", "Next Steps", [
       "1. Add the DNS records shown above to your domain registrar",
-      `2. Run \`playcademy domain verify ${normalizedHostname} --env ${options.env}\` to check validation status`,
+      `2. Run \`playcademy domain verify ${normalizedHostname} --env ${environment}\` to check validation status`,
       "",
       "Note: DNS propagation can take up to 24 hours. SSL certificates",
       "are provisioned automatically once DNS records are verified.",
@@ -14665,7 +14665,7 @@ import { confirm as confirm16 } from "@inquirer/prompts";
 async function runDomainDelete(hostname, options) {
   try {
     logger.newLine();
-    requireEnvironment(options.env, hostname);
+    requireEnvironment(options.env, `domain delete ${hostname}`);
     await requireConfigFile();
     const config = await loadConfig();
     const slug = getSlugFromConfig(config);
@@ -14707,7 +14707,7 @@ async function runDomainList(options) {
     if (!options.raw && !options.json) {
       logger.newLine();
     }
-    requireEnvironment(options.env);
+    requireEnvironment(options.env, "domain list");
     await requireConfigFile();
     const config = await loadConfig();
     const slug = getSlugFromConfig(config);
@@ -14757,7 +14757,7 @@ async function runDomainVerify(hostname, options) {
     if (!options.json) {
       logger.newLine();
     }
-    requireEnvironment(options.env, hostname);
+    const environment = requireEnvironment(options.env, `domain verify ${hostname}`);
     await requireConfigFile();
     const config = await loadConfig();
     const slug = getSlugFromConfig(config);
@@ -14783,7 +14783,9 @@ async function runDomainVerify(hostname, options) {
       logger.newLine();
     } else if (domain.status === "pending" || domain.status === "pending_validation" || domain.sslStatus === "pending_validation") {
       logger.admonition("tip", "Still Pending", [
-        "DNS records can take up to 24 hours to propagate."
+        "DNS records can take up to 24 hours to propagate.",
+        "",
+        `Run \`playcademy domain verify ${hostname} --env ${environment}\` again to check status.`
       ]);
       logger.newLine();
     }

package/dist/templates/playcademy-env.d.ts.template

@@ -15,7 +15,8 @@ declare global {
     interface PlaycademyEnv {
         PLAYCADEMY_API_KEY: string
         GAME_ID: string
-        PLAYCADEMY_BASE_URL: string{{BINDINGS}}{{SECRETS}}
+        PLAYCADEMY_BASE_URL: string
+        SELF: { fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response> }{{BINDINGS}}{{SECRETS}}
     }{{VARIABLES}}
 
     type Context = HonoContext<{ Bindings: PlaycademyEnv{{CONTEXT_VARS}} }>

package/dist/utils.js

@@ -2358,7 +2358,7 @@ import { join as join12 } from "path";
 // package.json with { type: 'json' }
 var package_default2 = {
   name: "playcademy",
-  version: "0.16.9",
+  version: "0.16.10",
   type: "module",
   exports: {
     ".": {

package/dist/version.js

@@ -1,7 +1,7 @@
 // package.json with { type: 'json' }
 var package_default = {
   name: "playcademy",
-  version: "0.16.9",
+  version: "0.16.10",
   type: "module",
   exports: {
     ".": {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "playcademy",
-    "version": "0.16.10",
+    "version": "0.16.11",
     "type": "module",
     "exports": {
         ".": {