codex-copilot-dx 0.6.11 → 0.6.13

package/README.md

@@ -118,11 +118,15 @@ discovery tries the compatible local CCDX merge first, and only exact enabled
 Anthropic model IDs use the isolated CCDX Claude profile. Neither credential is
 copied into the other application.
 
-The current patch recipes support only the exact, unmodified PM Studio 2.9.7
-and 2.9.10 bundles on macOS. This is exact-version support, not a version range:
-2.9.11 and other unknown builds remain unsupported until they receive their own
-verified recipe. Authorize the isolated Claude profile first, quit PM Studio
-and its updater, then run the one-time setup command:
+CCDX treats the local PM Studio App selected for setup as the source of truth.
+Its version and build label backup and recovery records; neither they nor the
+installation source or original signature are compatibility admission gates.
+Setup derives a source-bound recipe whenever the local ASAR integrity metadata
+and exactly one compatible Copilot configuration module can be verified. A
+missing or ambiguous module, changed request transport, or unsupported
+integrity policy is rejected without modifying the App. Authorize the isolated
+Claude profile first, quit PM Studio and its updater, then run the one-time
+setup command:
 
 ```bash
 ccdx auth login claude --reauth --github-login <personal-github-login>
@@ -138,24 +142,21 @@ ccdx pms status
 
 `ccdx pm-studio status` and `ccdx pm-studio setup` are equivalent long-form aliases.
 
-`ccdx pms setup` performs only local preflight, backup, staging, integrity,
-signing, and replacement work. It never starts Device Flow, the adapter,
-Codex, or PM Studio, and it does not modify PM profiles, cached model lists, or
-saved PM tokens. Unknown versions, hashes, signatures, partial patches, a
-running PM process, insufficient space, and every pre-replacement verification
-failure leave the installed App unchanged. If the final read-only verification
-after an atomic replacement detects an exceptional filesystem drift, setup
-does not attempt a second automatic write: it preserves the verified backup,
-retains any diagnostic stage still present, and prints recovery paths. Repeating
-setup for the exact installed recipe is idempotent.
-
-The official 2.9.10 artifact can fail macOS's vendor-signature verifier even
-though its signing metadata remains readable. CCDX does not generally ignore
-that failure: the 2.9.10 exception is accepted only when the complete App tree,
-including every file, mode, symlink, and non-volatile extended attribute,
-matches the frozen official fingerprint. The staged and installed CCDX patch
-must still pass strict ad-hoc signature verification and match the complete
-patched-tree record in the backup manifest.
+`ccdx pms setup` performs local preflight, structural verification, backup,
+staging, integrity, signing, and replacement work. It does not access a PM
+Studio repository, release asset, PAT, or source-signing service. It never
+starts Device Flow, the adapter, Codex, or PM Studio, and it does not modify PM
+profiles, cached model lists, or saved PM tokens. Local fingerprints bind the
+recipe, backup, staged App, and installed App without deciding whether the
+original package is trusted. Structure, partial-patch, running-process, space,
+and every other pre-replacement failure leave the installed App unchanged. If final
+read-only verification after an atomic replacement detects exceptional
+filesystem drift, setup does not attempt a second automatic write: it preserves
+the verified backup, retains any diagnostic stage still present, and prints
+recovery paths. Repeating setup reuses the version/source-bound verified backup
+and is idempotent. The staged and installed CCDX patch must still pass strict
+ad-hoc signature verification, use the App's bundle identifier, and match the
+complete patched-tree record in the backup manifest.
 
 The patch uses split origins, not an App-wide proxy. GPT and other non-Claude
 inference requests remain on PM Studio's native official GitHub Copilot origin;
@@ -173,16 +174,15 @@ CCDX uses the PM bearer only to fetch or validate official model access; it is
 never used as the credential for the isolated Claude upstream request. Keep
 port 2026 local to the machine.
 
-Patching replaces the vendor signature with an ad-hoc signature. PM Studio's
+Patching applies an ad-hoc signature to the staged App. PM Studio's
 updater is not disabled; an official update may overwrite the patch or may
-require reinstalling the official App. Setup prints the verified backup and
+require reinstalling PM Studio. Setup prints the verified backup and
 manifest paths plus the version-matched restore procedure. Never restore a
 backup over a different PM Studio version or build.
 
 To restore, first quit PM Studio and its updater. Use the exact verified backup
 path printed by setup as `BACKUP_APP`, then confirm that both the installed App
-and backup still report the same version/build printed by setup (`2.9.7/2.9.7`
-or `2.9.10/2.9.10`):
+and backup still report the same version/build printed by setup:
 
 ```bash
 BACKUP_APP="<verified-backup-path-from-ccdx-pms-setup>"
@@ -192,8 +192,9 @@ BACKUP_APP="<verified-backup-path-from-ccdx-pms-setup>"
 /usr/bin/plutil -extract CFBundleVersion raw -o - "$BACKUP_APP/Contents/Info.plist"
 ```
 
-Only when all four values match the one exact recipe, move the patched App
-aside, restore the complete vendor bundle, and verify it before launch:
+Only when all four values match each other and the version/build recorded in the
+source-bound manifest, move the patched App aside, restore the complete local
+bundle, and verify it before launch:
 
 ```bash
 RECOVERY_DIR="$(/usr/bin/mktemp -d '/Applications/CCDX-PM-Studio-recovery.XXXXXX')"
@@ -204,12 +205,11 @@ mv "/Applications/PM Studio.app" "$PATCHED_APP"
 ccdx pms status
 ```
 
-For 2.9.10, the vendor `codesign` command may report the documented upstream
-signature failure; in that case the App-patch row from `ccdx pms status` must
-still classify the restored bundle as exact supported clean content rather than
-integrity drift. If the version check, copy, or both verification paths fail,
+The App-patch row from `ccdx pms status` must classify the restored bundle as
+the recorded clean local content rather than integrity drift. If the version
+check, copy, or either verification path fails,
 do not launch the restored App. Keep the moved patched bundle at `$PATCHED_APP`
-and reinstall the official PM Studio instead of applying a version-mismatched
+and reinstall PM Studio instead of applying a version-mismatched
 backup. CCDX never runs these restore commands or `sudo` automatically.
 
 To change the model used by Codex Auto-review, run:
@@ -280,8 +280,9 @@ The command exits with status `1` when it finds an invalid configuration and `0`
 The doctor checks the GitHub token, Codex config, Claude Code settings, Claude
 App gateway profile, adapter availability, and an installed PM Studio bundle.
 It ends with passed/warning/error totals and deduplicated next-step commands.
-An absent PM Studio installation is ignored; unsupported versions are reported
-without modification, while integrity drift remains an error.
+An absent PM Studio installation is ignored; versions whose compatibility
+cannot be safely verified are reported without modification, while integrity
+drift remains an error.
 
 For a read-only live check of the saved GitHub token, Copilot entitlement, and models endpoint, run:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-copilot-dx",
-  "version": "0.6.11",
+  "version": "0.6.13",
   "description": "Use Codex Desktop, Claude Code, and Claude App with GitHub Copilot",
   "author": "Dale Xiao",
   "type": "module",

package/src/cli-options.mjs

@@ -292,8 +292,8 @@ function topicHelp(name, topic) {
     doctor: `Usage:\n  ${name} doctor [--online] [--compat] [--profile codex|claude|all]\n\nChecks local credentials, client configuration, PM Studio state, and the adapter. --online validates account entitlement; --compat sends minimal inference requests and consumes a small amount of Copilot usage.`,
     status: `Usage:\n  ${name} status\n\nShows bounded runtime, routing, performance, cache, queue, and PM relay metrics from a running adapter.`,
     models: `Usage:\n  ${name} models [--profile codex|claude] [--format table|plain]\n\nPerforms a fresh, read-only Copilot model-directory lookup for one saved profile. Interactive terminals use a table by default.`,
-    pms: `Usage:\n  ${name} pms status [--format table|plain]\n  ${name} pms setup\n  ${name} pm-studio status [--format table|plain]\n  ${name} pm-studio setup\n\nInspects or installs the version-locked PM Studio loopback patch. setup modifies the installed app only after all preflight checks pass.`,
-    "pms setup": `Usage:\n  ${name} pms setup\n\nBacks up, patches, verifies, and ad-hoc signs an exactly supported PM Studio bundle. Unknown versions and drift are never modified.`,
+    pms: `Usage:\n  ${name} pms status [--format table|plain]\n  ${name} pms setup\n  ${name} pm-studio status [--format table|plain]\n  ${name} pm-studio setup\n\nInspects or installs the fail-closed PM Studio split-origin patch. setup modifies the installed app only after exact or semantic compatibility and source checks pass.`,
+    "pms setup": `Usage:\n  ${name} pms setup\n\nBacks up, patches, verifies, and ad-hoc signs an exact or structurally compatible PM Studio bundle. Unverifiable versions and drift are never modified.`,
     "pms status": `Usage:\n  ${name} pms status [--format table|plain]\n\nRead-only inspection of the installed PM Studio version, patch integrity, Claude profile, and relay availability. Interactive terminals use a table by default.`,
     usage: `Usage:\n  ${name} usage [--format table|plain]\n\nSummarizes local token usage metadata without reading prompt or completion content. Interactive terminals use a table by default.`,
     "auto-review-model": `Usage:\n  ${name} auto-review-model\n\nInteractively selects an enabled Responses model for Codex Auto-review.`,

package/src/doctor.mjs

@@ -599,11 +599,11 @@ export async function collectDoctorChecks({
     } else if (pm.app.state === "clean") {
       checks.push({
         kind: "warn",
-        message: `PM Studio ${version} is supported but not patched`,
+        message: `PM Studio ${version} has a compatible local patch structure but is not patched`,
         fix: "ccdx pms setup",
       });
     } else if (pm.app.state === "unsupported") {
-      checks.push({ kind: "warn", message: `PM Studio ${version} has no exact patch recipe; no files will be changed` });
+      checks.push({ kind: "warn", message: `PM Studio ${version} does not expose one uniquely compatible patch structure; no files will be changed` });
     } else if (pm.app.state === "drift" || pm.app.state === "error") {
       checks.push({ kind: "err", message: `PM Studio integrity check failed: ${pm.app.issues.join("; ")}` });
     }

package/src/pm-studio-asar.mjs

@@ -7,13 +7,43 @@ export const ELECTRON_ASAR_INTEGRITY_SENTINEL = "AGbevlPCksUGKNL8TSn7wGmJEuJsXb2
 
 const PM_STUDIO_COPILOT_CONFIG_MODULE_LENGTH = 2_121;
 const PM_STUDIO_COPILOT_CONFIG_MODULE_SOURCE_SHA256 = "3da6245d676015ab6cd26e4d6a0d2f54894a687c370aa419c5ad170533d086aa";
+const PM_STUDIO_COPILOT_CONFIG_MODULE_ANCHOR = "47024(I,e,t){";
+const PM_STUDIO_COPILOT_CONFIG_MODULE_SENTINEL = `API_ENDPOINT:"${PM_STUDIO_ORIGIN}"`;
+const PM_STUDIO_COPILOT_CONFIG_MODULE_PATH = "dist/main/main.js";
+const PM_STUDIO_COMPATIBILITY_ID = "exact-copilot-config-module-v1";
+const PM_STUDIO_COMPATIBLE_TARGET_MAX_BYTES = 128 * 1024 * 1024;
+const PM_STUDIO_COMPATIBLE_BLOCK_MAX_COUNT = 16_384;
+const PM_STUDIO_COMPATIBLE_MODULE_PREFIX_MAX_BYTES = 512;
+const PM_STUDIO_COPILOT_CONFIG_MODULE_SOURCE = '47024(I,e,t){"use strict";t.d(e,{qn:()=>l});const l={CLIENT_ID:"Iv1.b507a08c87ecfe98",CLIENT_SECRET:void 0,API_ENDPOINT:"https://api.githubcopilot.com",DEVICE_CODE_URL:"https://github.com/login/device/code",ACCESS_TOKEN_URL:"https://github.com/login/oauth/access_token",COPILOT_TOKEN_URL:"https://api.github.com/copilot_internal/v2/token",USER_AGENT:"GitHubCopilotChat/0.26.7",EDITOR_VERSION:"vscode/1.99.3",EDITOR_PLUGIN_VERSION:"copilot-chat/0.26.7",INTEGRATION_ID:"vscode-chat",STANDARD_HEADERS:{Accept:"application/json","Content-Type":"application/json","User-Agent":"GitHubCopilotChat/0.26.7","Editor-Version":"vscode/1.99.3","Editor-Plugin-Version":"copilot-chat/0.26.7","Copilot-Integration-Id":"vscode-chat","X-Request-Id":()=>`req_${Date.now()}_${Math.random().toString(36).substr(2,9)}`}};class c{constructor(){this.config={...l}}static getInstance(){return c.instance||(c.instance=new c),c.instance}getConfig(){return{...this.config}}updateConfig(I){this.config={...this.config,...I}}resetConfig(){this.config={...l}}validateConfig(){return function(){const I=[];return l.CLIENT_ID||I.push("GitHub Copilot Client ID is required"),l.API_ENDPOINT||I.push("GitHub Copilot API endpoint is required"),{valid:0===I.length,errors:I}}()}getStandardHeaders(I){return function(I){const e={Accept:l.STANDARD_HEADERS.Accept,"Content-Type":l.STANDARD_HEADERS["Content-Type"],"User-Agent":l.STANDARD_HEADERS["User-Agent"],"Editor-Version":l.STANDARD_HEADERS["Editor-Version"],"Editor-Plugin-Version":l.STANDARD_HEADERS["Editor-Plugin-Version"],"Copilot-Integration-Id":l.STANDARD_HEADERS["Copilot-Integration-Id"],"X-Request-Id":"function"==typeof l.STANDARD_HEADERS["X-Request-Id"]?l.STANDARD_HEADERS["X-Request-Id"]():l.STANDARD_HEADERS["X-Request-Id"]};return I&&(e.Authorization=`Bearer ${I}`),e}(I)}getCopilotTokenHeaders(I){return function(I){return{Authorization:`Bearer ${I}`,Accept:"application/json","User-Agent":l.USER_AGENT,"Editor-Version":l.EDITOR_VERSION,"Editor-Plugin-Version":l.EDITOR_PLUGIN_VERSION}}(I)}getDeviceCodeHeaders(){return{Accept:"application/json","User-Agent":l.USER_AGENT}}}c.getInstance()}';
+
+function copilotConfigAlphaTemplate() {
+  // This is a reviewed byte template, not a generic JavaScript normalizer:
+  // only the five minifier bindings vary; every other byte remains exact.
+  const parts = [];
+  const moduleIdEnd = PM_STUDIO_COPILOT_CONFIG_MODULE_SOURCE.indexOf("(");
+  const pattern = /(?<![$\w])(?:I|e|t|l|c)(?![$\w])/g;
+  pattern.lastIndex = moduleIdEnd;
+  let offset = moduleIdEnd;
+  for (let match = pattern.exec(PM_STUDIO_COPILOT_CONFIG_MODULE_SOURCE); match; match = pattern.exec(PM_STUDIO_COPILOT_CONFIG_MODULE_SOURCE)) {
+    parts.push(PM_STUDIO_COPILOT_CONFIG_MODULE_SOURCE.slice(offset, match.index));
+    parts.push(Object.freeze({ identifier: match[0] }));
+    offset = match.index + match[0].length;
+  }
+  parts.push(PM_STUDIO_COPILOT_CONFIG_MODULE_SOURCE.slice(offset));
+  return Object.freeze(parts);
+}
 
-function splitOriginConfigModule() {
-  const source = `47024(I,e,t){"use strict";t.d(e,{qn:()=>l});const l={CLIENT_ID:"Iv1.b507a08c87ecfe98",CLIENT_SECRET:void 0,API_ENDPOINT:"${PM_STUDIO_ORIGIN}",DEVICE_CODE_URL:"https://github.com/login/device/code",ACCESS_TOKEN_URL:"https://github.com/login/oauth/access_token",COPILOT_TOKEN_URL:"https://api.github.com/copilot_internal/v2/token",USER_AGENT:"GitHubCopilotChat/0.26.7",EDITOR_VERSION:"vscode/1.99.3",EDITOR_PLUGIN_VERSION:"copilot-chat/0.26.7",INTEGRATION_ID:"vscode-chat",STANDARD_HEADERS:{Accept:"application/json","Content-Type":"application/json","User-Agent":"GitHubCopilotChat/0.26.7","Editor-Version":"vscode/1.99.3","Editor-Plugin-Version":"copilot-chat/0.26.7","Copilot-Integration-Id":"vscode-chat","X-Request-Id":()=>\`req_\${Date.now()}_\${Math.random().toString(36).substr(2,9)}\`}};const c=fetch.bind(globalThis),n="${CCDX_PM_STUDIO_ORIGIN}",a="${PM_STUDIO_SPLIT_ORIGIN_MARKER}",h="X-CCDX-PM-Relay",d=new Set,m=I=>I.headers.get(h)===a,q=I=>AbortSignal.any([I,AbortSignal.timeout(750)].filter(Boolean)),f=(I,e=400)=>Response.json({error:{code:I}},{status:e,headers:{[h]:a}});globalThis.fetch=async(I,e)=>{const t=I.url||I+"";if(t===\`\${l.API_ENDPOINT}/models\`){try{const t=await c(\`\${n}/models\`,e);if(t.ok&&m(t))try{let I=await t.clone().json(),e=I.data||I;if(Array.isArray(e)){d.clear();for(const I of e)/anthropic/i.test(I.vendor||I.owned_by)&&d.add(I.id);return t}}catch{}t.body?.cancel?.()?.catch?.(()=>{})}catch(I){if(e?.signal?.aborted)throw e.signal.reason||I}return c(I,e)}const s=t.startsWith(l.API_ENDPOINT)?t.slice(l.API_ENDPOINT.length):"";if("POST"===e?.method&&["/chat/completions","/responses","/embeddings"].includes(s)){let t="";try{t=(JSON.parse(e.body).model||"").trim()}catch{}if(d.has(t)||/^claude-/i.test(t)){if("/chat/completions"!==s)return f("model_not_supported");try{const I=await c(\`\${n}/models\`,{signal:q(e?.signal)}),t=401===I.status&&m(I);await I.text();if(!t)throw 0;const l=await c(\`\${n}\${s}\`,e);if(!m(l)){await l.body?.cancel?.();throw 0}return l}catch(I){if(e?.signal?.aborted)throw e.signal.reason||I;return f("relay_incompatible",503)}}}return c(I,e)}}`;
-  if (source.length > PM_STUDIO_COPILOT_CONFIG_MODULE_LENGTH) {
+const PM_STUDIO_COPILOT_CONFIG_ALPHA_TEMPLATE = copilotConfigAlphaTemplate();
+
+function splitOriginConfigModule(
+  moduleId = "47024",
+  windowLength = PM_STUDIO_COPILOT_CONFIG_MODULE_LENGTH,
+) {
+  const source = `${moduleId}(I,e,t){"use strict";t.d(e,{qn:()=>l});const l={CLIENT_ID:"Iv1.b507a08c87ecfe98",CLIENT_SECRET:void 0,API_ENDPOINT:"${PM_STUDIO_ORIGIN}",DEVICE_CODE_URL:"https://github.com/login/device/code",ACCESS_TOKEN_URL:"https://github.com/login/oauth/access_token",COPILOT_TOKEN_URL:"https://api.github.com/copilot_internal/v2/token",USER_AGENT:"GitHubCopilotChat/0.26.7",EDITOR_VERSION:"vscode/1.99.3",EDITOR_PLUGIN_VERSION:"copilot-chat/0.26.7",INTEGRATION_ID:"vscode-chat",STANDARD_HEADERS:{Accept:"application/json","Content-Type":"application/json","User-Agent":"GitHubCopilotChat/0.26.7","Editor-Version":"vscode/1.99.3","Editor-Plugin-Version":"copilot-chat/0.26.7","Copilot-Integration-Id":"vscode-chat","X-Request-Id":()=>\`req_\${Date.now()}_\${Math.random().toString(36).substr(2,9)}\`}};const c=fetch.bind(globalThis),n="${CCDX_PM_STUDIO_ORIGIN}",a="${PM_STUDIO_SPLIT_ORIGIN_MARKER}",h="X-CCDX-PM-Relay",d=new Set,m=I=>I.headers.get(h)===a,q=I=>AbortSignal.any([I,AbortSignal.timeout(750)].filter(Boolean)),f=(I,e=400)=>Response.json({error:{code:I}},{status:e,headers:{[h]:a}});globalThis.fetch=async(I,e)=>{const t=I.url||I+"";if(t===\`\${l.API_ENDPOINT}/models\`){try{const t=await c(\`\${n}/models\`,e);if(t.ok&&m(t))try{let I=await t.clone().json(),e=I.data||I;if(Array.isArray(e)){d.clear();for(const I of e)/anthropic/i.test(I.vendor||I.owned_by)&&d.add(I.id);return t}}catch{}t.body?.cancel?.()?.catch?.(()=>{})}catch(I){if(e?.signal?.aborted)throw e.signal.reason||I}return c(I,e)}const s=t.startsWith(l.API_ENDPOINT)?t.slice(l.API_ENDPOINT.length):"";if("POST"===e?.method&&["/chat/completions","/responses","/embeddings"].includes(s)){let t="";try{t=(JSON.parse(e.body).model||"").trim()}catch{}if(d.has(t)||/^claude-/i.test(t)){if("/chat/completions"!==s)return f("model_not_supported");try{const I=await c(\`\${n}/models\`,{signal:q(e?.signal)}),t=401===I.status&&m(I);await I.text();if(!t)throw 0;const l=await c(\`\${n}\${s}\`,e);if(!m(l)){await l.body?.cancel?.();throw 0}return l}catch(I){if(e?.signal?.aborted)throw e.signal.reason||I;return f("relay_incompatible",503)}}}return c(I,e)}}`;
+  if (source.length > windowLength) {
     throw new Error("PM Studio split-origin module exceeds its exact source window");
   }
-  return `${source.slice(0, -1)}${" ".repeat(PM_STUDIO_COPILOT_CONFIG_MODULE_LENGTH - source.length)}}`;
+  return `${source.slice(0, -1)}${" ".repeat(windowLength - source.length)}}`;
 }
 
 export const PM_STUDIO_SPLIT_ORIGIN_CONFIG_MODULE = splitOriginConfigModule();
@@ -315,6 +345,93 @@ function occurrencePositions(haystack, needle) {
   return positions;
 }
 
+function asciiDigit(byte) {
+  return byte >= 48 && byte <= 57;
+}
+
+function asciiIdentifierStart(byte) {
+  return byte === 36
+    || byte === 95
+    || (byte >= 65 && byte <= 90)
+    || (byte >= 97 && byte <= 122);
+}
+
+function matchCopilotConfigAlphaTemplate(source, offset) {
+  let moduleIdEnd = offset;
+  while (moduleIdEnd < source.length && asciiDigit(source[moduleIdEnd])) moduleIdEnd += 1;
+  const moduleIdLength = moduleIdEnd - offset;
+  if (moduleIdLength === 0
+    || moduleIdLength > 10
+    || (moduleIdLength > 1 && source[offset] === 48)) return null;
+  const moduleId = source.subarray(offset, moduleIdEnd).toString("ascii");
+  if (!Number.isSafeInteger(Number(moduleId))) return null;
+
+  let cursor = moduleIdEnd;
+  const identifiers = new Map();
+  const reverseIdentifiers = new Map();
+  for (const part of PM_STUDIO_COPILOT_CONFIG_ALPHA_TEMPLATE) {
+    if (typeof part === "string") {
+      const literal = Buffer.from(part);
+      if (cursor + literal.length > source.length
+        || !source.subarray(cursor, cursor + literal.length).equals(literal)) return null;
+      cursor += literal.length;
+      continue;
+    }
+
+    if (!asciiIdentifierStart(source[cursor])
+      || asciiIdentifierStart(source[cursor + 1])
+      || asciiDigit(source[cursor + 1])) return null;
+    const candidate = String.fromCharCode(source[cursor]);
+    // The audited module uses single-byte minifier names. Keeping that bound
+    // rejects capture-prone "semantic" guesses while allowing permutations.
+    const mapped = identifiers.get(part.identifier);
+    const reverse = reverseIdentifiers.get(candidate);
+    if ((mapped && mapped !== candidate) || (reverse && reverse !== part.identifier)) return null;
+    identifiers.set(part.identifier, candidate);
+    reverseIdentifiers.set(candidate, part.identifier);
+    cursor += 1;
+  }
+
+  if (cursor < source.length && source[cursor] !== 44 && source[cursor] !== 125) return null;
+  return {
+    offset,
+    end: cursor,
+    length: cursor - offset,
+    moduleId,
+    anchor: `${moduleId}(`,
+  };
+}
+
+function locateCompatibleCopilotConfigModule(source) {
+  const sentinel = Buffer.from(PM_STUDIO_COPILOT_CONFIG_MODULE_SENTINEL);
+  const matches = new Map();
+  let sentinelCount = 0;
+  let searchOffset = 0;
+  while (searchOffset <= source.length - sentinel.length) {
+    const sentinelOffset = source.indexOf(sentinel, searchOffset);
+    if (sentinelOffset < 0) break;
+    sentinelCount += 1;
+    searchOffset = sentinelOffset + sentinel.length;
+
+    const lowerBound = Math.max(0, sentinelOffset - PM_STUDIO_COMPATIBLE_MODULE_PREFIX_MAX_BYTES);
+    for (let offset = lowerBound; offset <= sentinelOffset; offset += 1) {
+      if (!asciiDigit(source[offset]) || (offset > 0 && asciiDigit(source[offset - 1]))) continue;
+      if (offset > 0 && source[offset - 1] !== 44 && source[offset - 1] !== 123) continue;
+      const match = matchCopilotConfigAlphaTemplate(source, offset);
+      if (match && sentinelOffset >= match.offset && sentinelOffset < match.end) {
+        matches.set(match.offset, match);
+      }
+    }
+  }
+  if (sentinelCount === 0) {
+    throw incompatibleAsar(`${PM_STUDIO_COPILOT_CONFIG_MODULE_PATH} has no compatible Copilot configuration sentinel`);
+  }
+  if (matches.size !== 1) {
+    throw incompatibleAsar(`${PM_STUDIO_COPILOT_CONFIG_MODULE_PATH} has ${matches.size} alpha-compatible Copilot configuration modules, expected exactly one`);
+  }
+  return matches.values().next().value;
+}
+
 export function blockSha256(buffer, blockSize) {
   const size = integer(blockSize, "block size");
   if (size === 0) throw new Error("Invalid ASAR block size: 0");
@@ -326,6 +443,159 @@ export function blockSha256(buffer, blockSize) {
   return hashes;
 }
 
+function incompatibleAsar(message) {
+  const error = new Error(message);
+  error.code = "PM_STUDIO_ASAR_INCOMPATIBLE";
+  return error;
+}
+
+function requiredRecipeString(value, name) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw incompatibleAsar(`PM Studio compatible recipe has no ${name}`);
+  }
+  return value;
+}
+
+export function createCompatiblePmStudioRecipe(value, options = {}) {
+  const parsed = parseAsarBuffer(value);
+  const entry = findAsarEntry(parsed.header, PM_STUDIO_COPILOT_CONFIG_MODULE_PATH);
+  if (!entry) throw incompatibleAsar(`${PM_STUDIO_COPILOT_CONFIG_MODULE_PATH} is missing`);
+
+  let targetOffset;
+  let targetSize;
+  let blockSize;
+  try {
+    targetOffset = entryOffset(entry.offset, `${PM_STUDIO_COPILOT_CONFIG_MODULE_PATH} offset`);
+    targetSize = entrySize(entry.size, `${PM_STUDIO_COPILOT_CONFIG_MODULE_PATH} size`);
+    blockSize = integer(entry.integrity?.blockSize,
+      `${PM_STUDIO_COPILOT_CONFIG_MODULE_PATH} block size`);
+  } catch (error) {
+    throw incompatibleAsar(error.message);
+  }
+  const absoluteOffset = parsed.dataOffset + targetOffset;
+  if (entry.unpacked || entry.link || absoluteOffset + targetSize > parsed.buffer.length) {
+    throw incompatibleAsar(`${PM_STUDIO_COPILOT_CONFIG_MODULE_PATH} is not one packed regular ASAR entry`);
+  }
+  if (blockSize === 0
+    || entry.integrity?.algorithm !== "SHA256"
+    || !sameArray(Object.keys(entry.integrity || {}).sort(), ["algorithm", "blockSize", "blocks", "hash"])) {
+    throw incompatibleAsar(`${PM_STUDIO_COPILOT_CONFIG_MODULE_PATH} has unsupported integrity metadata`);
+  }
+  const expectedBlockCount = Math.ceil(targetSize / blockSize);
+  if (targetSize > PM_STUDIO_COMPATIBLE_TARGET_MAX_BYTES
+    || blockSize < 16
+    || expectedBlockCount > PM_STUDIO_COMPATIBLE_BLOCK_MAX_COUNT
+    || entry.integrity.blocks.length !== expectedBlockCount) {
+    throw incompatibleAsar(`${PM_STUDIO_COPILOT_CONFIG_MODULE_PATH} has unsafe integrity block geometry`);
+  }
+
+  const sourceTarget = parsed.buffer.subarray(absoluteOffset, absoluteOffset + targetSize);
+  const sourceTargetSha256 = sha256Hex(sourceTarget);
+  const sourceBlocks = blockSha256(sourceTarget, blockSize);
+  if (entry.integrity.hash !== sourceTargetSha256
+    || !sameArray(entry.integrity.blocks, sourceBlocks)) {
+    throw incompatibleAsar(`${PM_STUDIO_COPILOT_CONFIG_MODULE_PATH} integrity metadata does not match its bytes`);
+  }
+
+  const compatibleModule = locateCompatibleCopilotConfigModule(sourceTarget);
+  const editOffset = compatibleModule.offset;
+  const editEnd = compatibleModule.end;
+  const sourceEdit = sourceTarget.subarray(editOffset, editEnd);
+  const anchorPositions = occurrencePositions(sourceTarget, Buffer.from(compatibleModule.anchor));
+  if (anchorPositions.length !== 1 || anchorPositions[0] !== editOffset) {
+    throw incompatibleAsar(`${PM_STUDIO_COPILOT_CONFIG_MODULE_PATH} compatible module header is not unique`);
+  }
+  let replacementSource;
+  try {
+    replacementSource = splitOriginConfigModule(compatibleModule.moduleId, compatibleModule.length);
+  } catch (error) {
+    throw incompatibleAsar(error.message);
+  }
+  const replacement = Buffer.from(replacementSource);
+  if (replacement.length !== compatibleModule.length) {
+    throw incompatibleAsar("PM Studio split-origin replacement does not preserve the compatible module size");
+  }
+  const patchedTarget = Buffer.from(sourceTarget);
+  replacement.copy(patchedTarget, editOffset);
+  const patchedTargetSha256 = sha256Hex(patchedTarget);
+  const patchedBlocks = blockSha256(patchedTarget, blockSize);
+  const patchedAsar = Buffer.from(parsed.buffer);
+  replacement.copy(patchedAsar, absoluteOffset + editOffset);
+  const patchedParsed = parseAsarBuffer(patchedAsar);
+  const patchedEntry = findAsarEntry(patchedParsed.header, PM_STUDIO_COPILOT_CONFIG_MODULE_PATH);
+  patchedEntry.integrity = {
+    ...patchedEntry.integrity,
+    algorithm: "SHA256",
+    hash: patchedTargetSha256,
+    blockSize,
+    blocks: [...patchedBlocks],
+  };
+  const patchedHeaderBytes = Buffer.from(JSON.stringify(patchedParsed.header));
+  if (patchedHeaderBytes.length !== patchedParsed.headerLength) {
+    throw incompatibleAsar(`Compatible ASAR header changed size (${patchedParsed.headerLength} -> ${patchedHeaderBytes.length})`);
+  }
+  patchedHeaderBytes.copy(patchedAsar, patchedParsed.headerStart);
+
+  const version = requiredRecipeString(String(options.version || ""), "version");
+  const build = requiredRecipeString(String(options.build || ""), "build");
+  const bundleIdentifier = requiredRecipeString(options.bundleIdentifier, "bundle identifier");
+  const sourceAsarSha256 = sha256Hex(parsed.buffer);
+  const identity = sha256Hex(`${PM_STUDIO_COMPATIBILITY_ID}\0${bundleIdentifier}\0${version}\0${build}\0${sourceAsarSha256}`).slice(0, 24);
+  const sourceBundleContent = options.sourceBundleContent
+    ? Object.freeze({
+      ...options.sourceBundleContent,
+      ignoredXattrs: Object.freeze([...(options.sourceBundleContent.ignoredXattrs || [])]),
+    })
+    : undefined;
+  const edit = Object.freeze({
+    offset: editOffset,
+    absoluteOffset: absoluteOffset + editOffset,
+    length: compatibleModule.length,
+    anchor: compatibleModule.anchor,
+    anchorCount: 1,
+    sourceSha256: sha256Hex(sourceEdit),
+    patchedSha256: sha256Hex(replacement),
+    replacement: replacementSource,
+  });
+  const target = Object.freeze({
+    path: PM_STUDIO_COPILOT_CONFIG_MODULE_PATH,
+    offset: targetOffset,
+    size: targetSize,
+    blockSize,
+    sourceSha256: sourceTargetSha256,
+    patchedSha256: patchedTargetSha256,
+    sourceBlocks: Object.freeze([...sourceBlocks]),
+    patchedBlocks: Object.freeze([...patchedBlocks]),
+    edit,
+  });
+  return Object.freeze({
+    id: `pm-studio-compatible-${identity}`,
+    compatibility: PM_STUDIO_COMPATIBILITY_ID,
+    version,
+    build,
+    bundleIdentifier,
+    sourceTeamIdentifier: requiredRecipeString(options.sourceTeamIdentifier, "source TeamIdentifier"),
+    executable: requiredRecipeString(options.executable, "executable"),
+    sourceExecutableSha256: requiredRecipeString(options.sourceExecutableSha256, "source executable SHA-256"),
+    electronFrameworkPath: requiredRecipeString(options.electronFrameworkPath, "Electron Framework path"),
+    sourceElectronFrameworkSha256: requiredRecipeString(
+      options.sourceElectronFrameworkSha256,
+      "source Electron Framework SHA-256",
+    ),
+    embeddedAsarIntegrity: requiredRecipeString(options.embeddedAsarIntegrity, "embedded ASAR integrity state"),
+    asarPath: requiredRecipeString(options.asarPath, "ASAR path"),
+    infoPlistPath: requiredRecipeString(options.infoPlistPath, "Info.plist path"),
+    integrityKey: requiredRecipeString(options.integrityKey, "ASAR integrity key"),
+    dataOffset: parsed.dataOffset,
+    sourceAsarSha256,
+    sourceHeaderSha256: sha256Hex(parsed.headerBytes),
+    patchedAsarSha256: sha256Hex(patchedAsar),
+    patchedHeaderSha256: sha256Hex(patchedHeaderBytes),
+    ...(sourceBundleContent ? { sourceBundleContent } : {}),
+    targets: Object.freeze([target]),
+  });
+}
+
 export function inspectElectronAsarIntegritySlots(value) {
   const buffer = checkedBuffer(value);
   const sentinel = Buffer.from(ELECTRON_ASAR_INTEGRITY_SENTINEL);