openxiangda 1.0.164 → 1.0.166

package/openxiangda-skills/references/resource-manifest-cheatsheet.md

@@ -572,13 +572,18 @@ JS_CODE 调用：`ctx.notification.sendByType({ ... })`。允许的 channels：`
 {
   "code": "reservation_reminder_summary",
   "name": "Reservation Reminder Summary",
+  "secretRefs": [
+    { "name": "notification_provider_token", "required": false }
+  ],
   "resources": {
     "forms": ["reservation_order"],
     "dataViews": ["reservation_order_overview"],
     "connectors": ["crm"]
   },
   "definitionJson": {
+    "version": "function_v2",
     "runtimeMode": "trusted_node",
+    "runtimeContractVersion": "trusted_node_v2",
     "timeout": 30000,
     "runtimeInvoke": {
       "audience": {
@@ -595,12 +600,19 @@ JS_CODE 调用：`ctx.notification.sendByType({ ... })`。允许的 channels：`
 
 ```ts
 // src/functions/reservation_reminder_summary/index.ts
-import type { AppFunctionContext } from "openxiangda/runtime";
+import type { AppFunctionContextV2 } from "openxiangda/runtime";
 
 export default async function reservationReminderSummary(
-  ctx: AppFunctionContext,
+  ctx: AppFunctionContextV2,
   input: { scope?: string },
 ) {
+  // Only resolve a name declared in top-level secretRefs. Never log or return it.
+  const providerToken = await ctx.secrets.get("notification_provider_token");
+  const providerResponse = await ctx.utils.http.post(
+    "https://api.dingtalk.com/v1.0/example/operation",
+    { requestId: input.scope || "default" },
+    { headers: { authorization: `Bearer ${providerToken}` } },
+  );
   const roleCodes = ctx.operator?.roleCodes || ctx.permissions?.roleCodes || [];
   const canManage =
     ctx.operator?.hasFullAccess === true ||
@@ -626,6 +638,7 @@ export default async function reservationReminderSummary(
   });
 
   return {
+    providerStatus: providerResponse.status,
     pendingCount: orders.totalCount || orders.data?.length || 0,
     detail,
     overview: overview.data || [],
@@ -634,6 +647,15 @@ export default async function reservationReminderSummary(
 }
 ```
 
+`ctx.utils.http` is the typed, server-controlled public HTTPS bridge for
+`trusted_node_v2`; it never forwards the platform Runtime bearer token and
+rejects redirects plus private/reserved network targets. For whole-app atomic
+activation, stage the exact backend scope with
+`openxiangda resource publish function --only <code> --stage-only`, combine its
+verified `stagedResource` with the other changed staged children, and pass that
+overlay to `openxiangda release app-finalize --staged-resources-json ...`.
+Already-active Backend Releases return `activeResource`, not a staged descriptor.
+
 调用方式：
 
 ```ts

package/openxiangda-skills/skills/openxiangda-core/SKILL.md

@@ -26,6 +26,8 @@ Run `openxiangda update check --json` once per substantial task, on a suspected
 
 Every write/release command must include `--profile <name>`. In a shared checkout, create an isolated Git worktree and named feature branch before editing. `sdd propose|quick|context` claims `.openxiangda/worktree-owner.json` for the current `CODEX_THREAD_ID`; a foreign owner is a hard stop. `.openxiangda/state.json` maps profile-local IDs; it is not a collaboration lock. The task is not complete until the exact frozen publish SHA is merged without squash/rebase and pushed to the authoritative default branch.
 
+SDD is permissive during coding and strict at release: `sdd verify --stage implementation` does not require unfinished checklist/evidence prose, and an omitted stage means prepublish rather than postpublish/archive. Exact command, child scope, and mainline gates apply only when staging or activating writes.
+
 First-class direct configuration writes (form/page/menu/role/permission/workflow/connector/notification/auth/route/public-access/scope/data-view/storage/settings) also require `--change <id>` or a complete stored session created by `openxiangda release begin --change <id>`. Missing context fails locally with `PUBLISH_CONTEXT_REQUIRED` before any HTTP write. Dry-run, schema planning, validation, query/invoke/export/submit/execution/upload, and other data-plane actions do not acquire a lease. Direct Workflow publish/unpublish/delete additionally requires the frozen `--expected-revision`; never fetch the latest revision merely to replay an older payload.
 
 ## Exact planning
@@ -55,7 +57,13 @@ openxiangda resource publish function --only function_a,function_b --profile <na
 
 Selectors apply before manifest parsing, source dependency analysis, and JS_CODE typecheck/build. A scoped Function/Automation plan must touch only the selected targets plus their transitive/shared/ambient dependencies; an unscoped plan intentionally retains full-workspace behavior. Resource commands use the canonical scoped builder packaged with the installed CLI for standard workspaces, so old checked-in builders still receive the optimization; refresh/bootstrap the workspace script only for equivalent manual `pnpm build-js-code` behavior. Nonstandard custom builders remain an explicit compatibility fallback.
 
-Source-triggered Function/Automation targets use one immutable Backend Release by default. The CLI uploads every eligible existing source-only target, freezes the current Backend Release parent plus Git/change baseline, then runs `prepare -> verify -> activate`; activation first CAS-checks the entire set and applies all updates in one transaction. Never fall back to sequential PATCH after prepare/verify/activate has started. Compatibility fallback is allowed only when the Backend Release `head` feature probe is an explicit HTTP 404, and must warn. Existing online bindings, contracts, metadata, trigger/view configuration, and enabled/published state remain unchanged; noops do not advance resource versions/timestamps. A deliberate whole-definition replacement requires exact `--only/--code` and `--replace-manifest --reason "<why>"`; SDD bypass does not imply replacement authority.
+Source-triggered Function/Automation targets use Backend Release v2 when the platform exposes that capability. One child may mix create, source-only update, and manifest replacement update through explicit per-resource `operation/mode`; the CLI freezes the current Backend Release parent plus Git/change baseline, then runs `prepare -> verify -> activate` or stops verified for `--stage-only`. Activation CAS-checks the entire set and applies all updates in one transaction. `--stage-only` and Secret-bound Function publishing fail closed when Backend Release v2 is unavailable; compatibility fallback is limited to non-staged, non-Secret publishing after an explicit Backend head 404. Existing online bindings, contracts, metadata, trigger/view configuration, and enabled/published state remain unchanged; noops do not advance versions/timestamps. A deliberate whole-definition replacement requires exact `--only/--code` and `--replace-manifest --reason "<why>"`; SDD bypass does not imply replacement authority.
+
+Functions with a top-level `secretRefs` field use `backend_release_v2`, including an explicit empty list that removes bindings. This path never falls back to source PATCH. It requires the per-app Secret capability probe to grant `app_function_secrets_v1`, `trusted_node_v2`, `backend_release_v2`, and `atomic_staged_children_v2`; otherwise plan/publish fails closed.
+
+For whole-app atomic activation, publish the exact mixed Function/Automation scope with `resource publish function,automation --only function:<code>,automation:<code> --stage-only --change <change>`. This stops after Backend Release verify and returns `stagedResource` plus every handled selector; the CLI automatically merges it with other changed staged children in `.openxiangda/releases/<change>/staged-resources.json` for `release app-finalize --staged-resources-json`. A Backend Release that was already activated returns `activeResource` and must not be presented as staged.
+
+Standard workspaces use the CLI-bundled scoped JS_CODE builder directly, including isolated Git-base checks; do not invoke `pnpm` merely to rebuild a selected Function/Automation. New snapshots carry `source_lineage_v1.sourceHash`, which is derived from authored source/dependencies rather than generated bundle bytes, so a builder upgrade does not falsely report source divergence.
 
 Use `openxiangda release backend-head|backend-list|backend-detail|backend-diff` to inspect immutable history. `backend-rollback <releaseId> --change <change> --reason "..."` prepares, verifies, and activates a new release from the historical snapshot; it never mutates or directly reactivates the old row. `backend-abort` stops prepared/verified work and `backend-retry` retries only recorded post-commit side effects. Do not fetch newer revisions to replay an older payload.
 
@@ -76,16 +84,16 @@ Do not call `lowcode-workspace publish-all`, `pnpm publish:all`, `pnpm publish:o
 
 ## React SPA
 
-Forms still publish schema shells explicitly. Resources and frontend runtime are separate releases:
+Forms, Backend resources, and frontend Runtime are staged children of one Root App release:
 
 ```bash
-openxiangda workspace publish --profile <name> --form <formCode>
+openxiangda resource publish form-setting --only <formCode> --change <change> --profile <name>
 openxiangda resource plan <type> --only <codes> --profile <name>
 openxiangda runtime deploy --change <change> --profile <name> --no-activate --json
-openxiangda sdd verify <change> --changed --stage prepublish
+openxiangda sdd verify <change> --changed --stage prepublish --profile <name>
 openxiangda release begin --change <change> --profile <name>
-openxiangda resource publish <type> --only <codes> --change <change> --profile <name>
-openxiangda runtime activate <reviewedReleaseId> --change <change> --profile <name>
+openxiangda resource publish function,automation --only function:<code>,automation:<code> --stage-only --change <change> --profile <name>
+openxiangda release app-finalize --staged-resources-json .openxiangda/releases/<change>/staged-resources.json --change <change> --profile <name>
 # Merge/fast-forward the frozen release SHA to the remote default branch.
 openxiangda release integration-status --profile <name>
 openxiangda release end --profile <name>

package/openxiangda-skills/skills/openxiangda-form/SKILL.md

@@ -23,9 +23,10 @@ openxiangda form list --profile <name>
 #   src/forms/<formCode>/schema.ts   — fields, options, rules, top-level FormEffect[]
 #   src/forms/<formCode>/page.tsx    — presentation only
 
-# 3. preview + publish single form
-openxiangda workspace publish --profile <name> --form <formCode> --dry-run
-openxiangda workspace publish --profile <name> --form <formCode>
+# 3. normal release: stage the exact Form bundle, then Root App finalize
+openxiangda resource plan form-setting --only <formCode> --profile <name>
+openxiangda resource publish form-setting --only <formCode> --change <change> --profile <name>
+openxiangda release app-finalize --staged-resources-json .openxiangda/releases/<change>/staged-resources.json --change <change> --profile <name>
 ```
 
 ## DO / DO NOT
@@ -71,19 +72,19 @@ src/forms/<formCode>/
 └── page.tsx
 ```
 
-Then publish:
+Then stage the exact Form bundle:
 
 ```bash
-openxiangda workspace publish --profile <name>
+openxiangda resource publish form-setting --only <formCodes> --change <change> --profile <name>
 ```
 
-For a single form edit, publish that form only:
+For a single form edit, still keep the child staged until Root App finalize:
 
 ```bash
-openxiangda workspace publish --profile <name> --form <formCode>
+openxiangda resource publish form-setting --only <formCode> --change <change> --profile <name>
 ```
 
-The workspace publish script receives `OPENXIANGDA_BASE_URL`, `OPENXIANGDA_ACCESS_TOKEN`, and `OPENXIANGDA_APP_TYPE` from the CLI. It creates/binds the platform form shell only when needed, syncs form metadata, builds the React form page bundle, uploads assets, and registers the bundle.
+The Form resource bundle carries schema, settings, indexes, data-management, runtime-write, and public-access configuration under one CAS parent. It returns a canonical staged FormRelease and the CLI records it in the change-scoped staged-resources file. `workspace publish --form` is limited to an intentional first-time bootstrap or isolated repair outside a governed multi-resource release; it is not the normal release path.
 
 For Phase 6 React SPA workspaces, `app-workspace.config.ts` should declare
 `runtimeMode: "react-spa"`. In that mode, `workspace publish --form <code>` is
@@ -109,7 +110,7 @@ Do not use `openxiangda form create` as the normal way to generate a user-facing
 ## Form Release / CAS Safety
 
 - Treat all Form configuration as one immutable release stream. Freeze `revision`, `etag`, and `activeFormReleaseHead` from one snapshot before writing.
-- Publish declared schema, packages, settings, indexes, data-management, runtime-write, and public-access configuration through one Form `bundle` mutation. Resource Form bundles are stage-only by default. For normal multi-resource work, add each changed `FormRelease` entry (stable identity is `formUuid`) to `--staged-resources-json` and let root `app-finalize` atomically switch all child heads plus the App head. Use direct `--activate` only for an intentional form-only repair.
+- Publish declared schema, packages, settings, indexes, data-management, runtime-write, and public-access configuration through one `resource publish form-setting --only <codes> --change <change>` Form `bundle` mutation. Resource Form bundles are stage-only by default and return immutable `contentHash` plus a canonical `stagedResource` (stable identity is `formUuid`); the CLI merges each entry into `.openxiangda/releases/<change>/staged-resources.json`. Root `app-finalize` atomically switches all child heads plus the App head. Use direct `--activate` only for an intentional form-only repair outside a governed multi-resource release; never use `workspace publish --form` inside an atomic React SPA release.
 - Every mutation must carry `If-Match`, `expectedRevision`, `expectedParent`, and a stable artifact ID. Creation starts at revision `0`.
 - A revision/head conflict is not retryable. Stop with zero later writes, re-plan, and explicitly merge the competing change; never silently adopt the newer live head.
 - Use `openxiangda form release-head|release-list|release-detail|release-diff` for inspection and `release-activate|release-rollback|release-abort` for controlled recovery. See `docs/openxiangda-form-releases.md` in the OpenXiangda tool repository.

package/openxiangda-skills/skills/openxiangda-workflow-automation/SKILL.md

@@ -105,6 +105,8 @@ JS_CODE is the backend execution escape hatch for workflow and automation. Use i
 
 App Function is the reusable backend execution model. Use it when the logic should be called by custom pages, multiple automations, workflows, or the runtime API. Source lives in `src/functions/<functionCode>/index.ts`; manifest lives in `src/resources/functions/<functionCode>.json`. Call it from pages with `sdk.function.invoke(code, { input })`, from graph definitions with `function_call`, or from the runtime endpoint `/:appType/v1/functions/:code/invoke.json`. Direct runtime invocation defaults to app automation management permission; ordinary page callers must declare `definitionJson.runtimeInvoke.audience` (`authenticated`, `page_permission_group`, `app_roles`, or `scope_policy`). Prefer `export default async function(ctx, input) {}` for App Function source; the second argument is the invoke input and the same value is available as `ctx.input`. Current MVP exposes controlled helpers only and does not expose raw SQL or Redis. `ctx.form.createOne/updateOne/updateById` are trusted backend writes governed by declared `resources.forms` and function invocation authorization; keep internal forms closed to direct user submit unless the business explicitly needs raw form submission. For internal function-only forms, set form settings `runtimeWrite.mode="function_only"` instead of relying only on missing submit permission groups.
 
+For third-party credentials, use top-level metadata-only `secretRefs` plus `definitionJson.version="function_v2"` and `runtimeContractVersion="trusted_node_v2"`; read a declared value with `await ctx.secrets.get(name)` and call public business APIs through `ctx.utils.http`. Never use `process.env` for platform secrets. Values are managed with `openxiangda secret create|rotate --value-stdin --change <change> --profile <name>` and never appear in Git, build output, snapshots, plan diffs, logs, exceptions, or traces. Local tests may use `function test --secret-from-env logical=ENV` only; the value is passed to an isolated child over stdin and is never written to workspace/cache/state. For a Root App transaction, use exact-scope `resource publish function --only <code> --stage-only` and include its verified `stagedResource` in `release app-finalize`.
+
 For new AI-authored automations, prefer code-first `automation_code_ts` resources instead of visual v3 graph definitions. Put the source in `src/automations/<resourceCode>/index.ts`, define `definition.code.json` with `kind: "automation_code_ts"`, and provide `preview.json` for read-only frontend display. Use `ctx.logger.debug/info/warn/error(message, data?)` at every important step; OpenXiangda can inspect logs with `automation executions`, `automation logs`, and `automation diagnose`.
 
 For new AI-authored workflows where users do not need canvas editing, prefer compile-time `workflow.ts` using `openxiangda/workflow`. The CLI compiles it to v3 `definitionJson` and `preview.json`; the backend still runs the normal workflow engine for approval tasks, copy tasks, callback waits, branch advancement, and process records.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openxiangda",
-  "version": "1.0.164",
+  "version": "1.0.166",
   "description": "OpenXiangda CLI, workspace build tools, runtime SDK, and form components.",
   "private": false,
   "bin": {
@@ -76,6 +76,7 @@
     "test:api-contract": "node scripts/openxiangda-api-contract-smoke.mjs",
     "test:help-no-side-effects": "node scripts/help-no-side-effects-smoke.mjs",
     "test:app-function-fallback": "node scripts/app-function-source-fallback-smoke.mjs",
+    "test:app-function-secrets": "node scripts/app-function-secrets-cli-smoke.mjs",
     "test:change-baseline": "node scripts/change-baseline-smoke.mjs",
     "test:change-baseline-publish": "node scripts/change-baseline-publish-smoke.mjs",
     "test:generic-base-preflight": "node scripts/generic-git-base-preflight-smoke.mjs",

package/packages/sdk/dist/runtime/index.cjs

@@ -2411,6 +2411,8 @@ var resolveLoginUrl = (appType, {
 var getCurrentHref2 = () => typeof window === "undefined" ? "" : window.location.href;
 
 // packages/sdk/src/runtime/core/publicAccess.ts
+var PUBLIC_SESSION_RENEW_WINDOW_MS = 5 * 60 * 1e3;
+var publicSessionInflight = /* @__PURE__ */ new Map();
 var PublicAccessClientError = class extends Error {
   constructor(message7, options = {}) {
     super(message7);
@@ -2438,48 +2440,144 @@ var createPublicAccessClient = ({
       userAgent: input.userAgent || getCurrentUserAgent(),
       guestIdentifier: input.guestIdentifier || getOrCreatePublicGuestIdentifier(normalizedAppType)
     };
-    const response = await boundFetch(
-      buildServiceUrl2(
-        servicePrefix,
-        `/openxiangda-api/v1/apps/${encodeURIComponent(
-          normalizedAppType
-        )}/public/session`
-      ),
-      {
-        method: "POST",
-        credentials: "include",
-        headers: {
-          accept: "application/json",
-          "content-type": "application/json"
-        },
-        body: JSON.stringify(body)
-      }
+    const identity = buildPublicSessionIdentity(
+      normalizedAppType,
+      servicePrefix,
+      body
     );
-    const payload = await readPayload2(response);
-    const code = getRecordValue2(payload, "code");
-    const success = getRecordValue2(payload, "success");
-    if (!response.ok || success === false || !isSuccessCode3(code)) {
-      throw new PublicAccessClientError(
-        String(
-          getRecordValue2(payload, "message") || `Public access session failed: ${response.status}`
+    const cached = readCachedPublicSession(identity);
+    if (cached) return cached;
+    const existing = publicSessionInflight.get(identity);
+    if (existing) return existing;
+    const pending = (async () => {
+      const response = await boundFetch(
+        buildServiceUrl2(
+          servicePrefix,
+          `/openxiangda-api/v1/apps/${encodeURIComponent(
+            normalizedAppType
+          )}/public/session`
         ),
-        { status: response.status, code, payload }
+        {
+          method: "POST",
+          credentials: "include",
+          headers: {
+            accept: "application/json",
+            "content-type": "application/json"
+          },
+          body: JSON.stringify(body)
+        }
       );
+      const payload = await readPayload2(response);
+      const code = getRecordValue2(payload, "code");
+      const success = getRecordValue2(payload, "success");
+      if (!response.ok || success === false || !isSuccessCode3(code)) {
+        throw new PublicAccessClientError(
+          String(
+            getRecordValue2(payload, "message") || `Public access session failed: ${response.status}`
+          ),
+          { status: response.status, code, payload }
+        );
+      }
+      const data = getRecordValue2(payload, "data");
+      const extra = getRecordValue2(payload, "extra");
+      const session = {
+        ...data,
+        publicAccess: extra?.publicAccess || null,
+        raw: payload
+      };
+      writeCachedPublicSession(identity, session);
+      return session;
+    })();
+    publicSessionInflight.set(identity, pending);
+    try {
+      return await pending;
+    } finally {
+      if (publicSessionInflight.get(identity) === pending) {
+        publicSessionInflight.delete(identity);
+      }
     }
-    const data = getRecordValue2(payload, "data");
-    const extra = getRecordValue2(payload, "extra");
-    return {
-      ...data,
-      publicAccess: extra?.publicAccess || null,
-      raw: payload
-    };
   };
   return {
     appType: normalizedAppType,
     servicePrefix,
-    startSession: request
+    startSession: request,
+    clearSession: (input = {}) => {
+      const body = {
+        ...input,
+        path: input.path || getCurrentPathname(),
+        domain: input.domain || getCurrentDomain(),
+        userAgent: input.userAgent || getCurrentUserAgent(),
+        guestIdentifier: input.guestIdentifier || getOrCreatePublicGuestIdentifier(normalizedAppType)
+      };
+      clearCachedPublicSession(
+        buildPublicSessionIdentity(normalizedAppType, servicePrefix, body)
+      );
+    }
   };
 };
+var buildPublicSessionIdentity = (appType, servicePrefix, input) => JSON.stringify({
+  appType,
+  servicePrefix: servicePrefix.replace(/\/$/, ""),
+  path: input.path || "",
+  policyCode: input.policyCode || "",
+  routeCode: input.routeCode || "",
+  ticket: input.ticket || "",
+  guestIdentifier: input.guestIdentifier || "",
+  domain: input.domain || ""
+});
+var publicSessionStorageKey = (identity) => {
+  let hash = 2166136261;
+  for (let index = 0; index < identity.length; index += 1) {
+    hash ^= identity.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return `openxiangda:public:session:v1:${identity.length}:${(hash >>> 0).toString(16)}`;
+};
+var readCachedPublicSession = (identity) => {
+  try {
+    if (typeof window === "undefined" || !window.sessionStorage) return null;
+    const raw = window.sessionStorage.getItem(publicSessionStorageKey(identity));
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    if (parsed.identity !== identity || !parsed.session) return null;
+    if (!isPublicSessionReusable(parsed.session)) {
+      clearCachedPublicSession(identity);
+      return null;
+    }
+    return parsed.session;
+  } catch {
+    return null;
+  }
+};
+var writeCachedPublicSession = (identity, session) => {
+  if (!isPublicSessionReusable(session)) return;
+  try {
+    if (typeof window === "undefined" || !window.sessionStorage) return;
+    const { raw: _raw, ...cacheableSession } = session;
+    window.sessionStorage.setItem(
+      publicSessionStorageKey(identity),
+      JSON.stringify({ identity, session: cacheableSession })
+    );
+  } catch {
+  }
+};
+var clearCachedPublicSession = (identity) => {
+  try {
+    if (typeof window !== "undefined" && window.sessionStorage) {
+      window.sessionStorage.removeItem(publicSessionStorageKey(identity));
+    }
+  } catch {
+  }
+};
+var isPublicSessionReusable = (session) => {
+  const accessTokenExpiresAt = Number(session.accessTokenExpiresAt);
+  if (!Number.isFinite(accessTokenExpiresAt) || accessTokenExpiresAt <= 0) {
+    return false;
+  }
+  const policyExpiresAt = session.publicAccess?.expiresAt ? new Date(session.publicAccess.expiresAt).getTime() : Number.POSITIVE_INFINITY;
+  const expiresAt = Math.min(accessTokenExpiresAt, policyExpiresAt);
+  return expiresAt - Date.now() >= PUBLIC_SESSION_RENEW_WINDOW_MS;
+};
 var buildServiceUrl2 = (servicePrefix, path) => {
   const prefix = servicePrefix.endsWith("/") ? servicePrefix.slice(0, -1) : servicePrefix;
   const suffix = path.startsWith("/") ? path : `/${path}`;
@@ -9915,29 +10013,40 @@ var usePublicAccess = (options = {}) => {
       setError(null);
       try {
         const resolvedPath = input.path || stableSessionInput.path || readPathFromLocation();
-        const data = await client.startSession({
+        const resolvedInput = {
           ...stableSessionInput,
           ...input,
           ticket: input.ticket || stableSessionInput.ticket || readTicketFromLocation(),
           path: resolvedPath
-        });
-        if (!mountedRef.current) return data;
-        activeSessionRef.current = {
-          accessToken: data.accessToken,
-          path: resolvedPath
         };
-        setSession(data);
-        setAccessToken(data.accessToken, {
-          scope: "public",
-          path: resolvedPath
-        });
-        await reloadRuntime({
-          accessToken: data.accessToken,
-          accessTokenOptions: {
+        let data = await client.startSession(resolvedInput);
+        if (!mountedRef.current) return data;
+        const activateSession = async (next) => {
+          activeSessionRef.current = {
+            accessToken: next.accessToken,
+            path: resolvedPath
+          };
+          setSession(next);
+          setAccessToken(next.accessToken, {
             scope: "public",
             path: resolvedPath
-          }
-        });
+          });
+          await reloadRuntime({
+            accessToken: next.accessToken,
+            accessTokenOptions: {
+              scope: "public",
+              path: resolvedPath
+            }
+          });
+        };
+        try {
+          await activateSession(data);
+        } catch (activationError) {
+          if (!isUnauthorizedPublicSessionError(activationError)) throw activationError;
+          client.clearSession(resolvedInput);
+          data = await client.startSession(resolvedInput);
+          await activateSession(data);
+        }
         if (!mountedRef.current) return data;
         setLoading(false);
         return data;
@@ -9999,6 +10108,13 @@ var readTicketFromLocation = () => {
   return new URLSearchParams(window.location.search).get("ticket") || void 0;
 };
 var readPathFromLocation = () => typeof window === "undefined" ? void 0 : window.location.pathname;
+var isUnauthorizedPublicSessionError = (error) => {
+  if (!error || typeof error !== "object") return false;
+  const status = Number(
+    error.status ?? error.statusCode
+  );
+  return status === 401 || status === 403;
+};
 
 // packages/sdk/src/runtime/host/builtinRouteRenderer.tsx
 var import_react88 = require("react");