@aura3d/rendering 3.0.1 → 4.0.2

package/dist/program/chunks/manifest.js

@@ -0,0 +1,48 @@
+/**
+ * PRD 11 Phase 6 groundwork (§7.3, ◦): WGSL twin manifest.
+ *
+ * C-02 `ShaderChunk.wgsl` is the twin field; chunks registered without it are
+ * reported — never fatal — until G-WGPU is a "go" (§6.2). Lane-11-owned
+ * chunks register their twins in `program/chunks/*.wgsl.ts` and pass them to
+ * `registerShaderChunk` directly; this manifest additionally records them so
+ * `manifestParity` can report coverage without a lane-01 enumeration API
+ * (requested via qr-request: `allShaderChunks()` on contracts/program.ts).
+ *
+ * `manifestParity(registered?)` takes an optional explicit list of
+ * `{name, owner}` descriptors — callers that do have chunk access (tests,
+ * the naga job) pass it; without it the manifest reports only the twins it
+ * knows about.
+ */
+const twins = new Map();
+/** Record a WGSL twin for a registered C-02 chunk. Idempotent per name. */
+export function registerWgslTwin(entry) {
+    twins.set(entry.chunkName, entry);
+}
+export function wgslTwinFor(chunkName) {
+    return twins.get(chunkName)?.wgsl;
+}
+export function wgslTwins() {
+    return [...twins.values()];
+}
+/**
+ * Compare the known registered chunks against the twin table.
+ * `registered` is optional until C-02 exposes enumeration; when omitted the
+ * report covers the manifest's own twin table (missing = []).
+ */
+export function manifestParity(registered) {
+    if (!registered) {
+        return { withTwin: twins.size, missing: [] };
+    }
+    const missing = [];
+    let withTwin = 0;
+    for (const chunk of registered) {
+        if (chunk.wgsl !== undefined || twins.has(chunk.name)) {
+            withTwin += 1;
+        }
+        else {
+            missing.push({ name: chunk.name, owner: chunk.owner ?? "unknown" });
+        }
+    }
+    return { withTwin, missing };
+}
+//# sourceMappingURL=manifest.js.map

package/dist/program/chunks/manifest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/program/chunks/manifest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAQH,MAAM,KAAK,GAAG,IAAI,GAAG,EAAyB,CAAC;AAE/C,2EAA2E;AAC3E,MAAM,UAAU,gBAAgB,CAAC,KAAoB;IACnD,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;AACpC,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,SAAiB;IAC3C,OAAO,KAAK,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,IAAI,CAAC;AACpC,CAAC;AAED,MAAM,UAAU,SAAS;IACvB,OAAO,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;AAC7B,CAAC;AAOD;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,UAAkG;IAC/H,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,OAAO,EAAE,QAAQ,EAAE,KAAK,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC;IAC/C,CAAC;IACD,MAAM,OAAO,GAAsC,EAAE,CAAC;IACtD,IAAI,QAAQ,GAAG,CAAC,CAAC;IACjB,KAAK,MAAM,KAAK,IAAI,UAAU,EAAE,CAAC;QAC/B,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,IAAI,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;YACtD,QAAQ,IAAI,CAAC,CAAC;QAChB,CAAC;aAAM,CAAC;YACN,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,IAAI,SAAS,EAAE,CAAC,CAAC;QACtE,CAAC;IACH,CAAC;IACD,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC;AAC/B,CAAC"}

package/dist/program/chunks/normal.glsl.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `normal` chunk — shading-normal helpers for generated programs.
+ * `FLAT_SHADING` derives the geometric normal with dFdx/dFdy; normal maps use
+ * the tangent frame (a_tangent when present, else the screen-space derivative
+ * fallback used by three.js perturbNormal2Arb).
+ */
+export declare const NORMAL_CHUNK_GLSL = "\nvec3 a3dFlatNormal(vec3 pos) {\n  vec3 fdx = dFdx(pos);\n  vec3 fdy = dFdy(pos);\n  return normalize(cross(fdx, fdy));\n}\n\n#ifdef USE_NORMAL_MAP\nuniform sampler2D u_normalMap;\nuniform float u_normalScale;\n// three r185 perturbNormal2Arb: screen-space derivative tangent frame.\nvec3 a3dTangentNormal(vec3 pos, vec3 surfaceNormal, vec2 mapUv) {\n  vec3 q0 = dFdx(pos);\n  vec3 q1 = dFdy(pos);\n  vec2 st0 = dFdx(mapUv);\n  vec2 st1 = dFdy(mapUv);\n  float scale = sign(st1.t * st0.s - st0.t * st1.s);\n  vec3 S = normalize((q0 * st1.t - q1 * st0.t) * scale);\n  vec3 T = normalize((-q0 * st1.s + q1 * st0.s) * scale);\n  vec3 N = normalize(surfaceNormal);\n  mat3 tsn = mat3(S, T, N);\n  vec3 mapN = texture(u_normalMap, mapUv).xyz * 2.0 - 1.0;\n  mapN.xy *= u_normalScale;\n  return normalize(tsn * mapN);\n}\n#endif\n";
+//# sourceMappingURL=normal.glsl.d.ts.map

package/dist/program/chunks/normal.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normal.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/program/chunks/normal.glsl.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,eAAO,MAAM,iBAAiB,8zBA0B7B,CAAC"}

package/dist/program/chunks/normal.glsl.js

@@ -0,0 +1,34 @@
+/**
+ * `normal` chunk — shading-normal helpers for generated programs.
+ * `FLAT_SHADING` derives the geometric normal with dFdx/dFdy; normal maps use
+ * the tangent frame (a_tangent when present, else the screen-space derivative
+ * fallback used by three.js perturbNormal2Arb).
+ */
+export const NORMAL_CHUNK_GLSL = /* glsl */ `
+vec3 a3dFlatNormal(vec3 pos) {
+  vec3 fdx = dFdx(pos);
+  vec3 fdy = dFdy(pos);
+  return normalize(cross(fdx, fdy));
+}
+
+#ifdef USE_NORMAL_MAP
+uniform sampler2D u_normalMap;
+uniform float u_normalScale;
+// three r185 perturbNormal2Arb: screen-space derivative tangent frame.
+vec3 a3dTangentNormal(vec3 pos, vec3 surfaceNormal, vec2 mapUv) {
+  vec3 q0 = dFdx(pos);
+  vec3 q1 = dFdy(pos);
+  vec2 st0 = dFdx(mapUv);
+  vec2 st1 = dFdy(mapUv);
+  float scale = sign(st1.t * st0.s - st0.t * st1.s);
+  vec3 S = normalize((q0 * st1.t - q1 * st0.t) * scale);
+  vec3 T = normalize((-q0 * st1.s + q1 * st0.s) * scale);
+  vec3 N = normalize(surfaceNormal);
+  mat3 tsn = mat3(S, T, N);
+  vec3 mapN = texture(u_normalMap, mapUv).xyz * 2.0 - 1.0;
+  mapN.xy *= u_normalScale;
+  return normalize(tsn * mapN);
+}
+#endif
+`;
+//# sourceMappingURL=normal.glsl.js.map

package/dist/program/chunks/normal.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normal.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/program/chunks/normal.glsl.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,CAAC,MAAM,iBAAiB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;CA0B3C,CAAC"}

package/dist/program/chunks/shadow_forward.glsl.d.ts

@@ -0,0 +1,23 @@
+/**
+ * `shadow_forward` chunk — directional/spot shadow-map receive for the
+ * generated forward program (#1225).
+ *
+ * The generated program (A3D_QR_CORE, default-on since #1238) replaced the
+ * legacy `aura3d/pbr-direct` shader for allow-listed materials, but its
+ * `fragment:lights` loop never sampled a shadow map: `forward/Lighting.ts`
+ * only binds `u_shadowMap*` when the program reflects them, so the bridged
+ * prd02 cascade (and the flag-off legacy map) was dropped and every capture
+ * was byte-identical to its no-shadows control.
+ *
+ * This chunk declares the legacy forward uniforms and the legacy
+ * `a3dForwardShadowFactor`, text-identical to ShaderLibraryCore.ts (a unit
+ * test pins the two), so the bound map is sampled exactly like the legacy
+ * shader does. Emitted only when the draw has a shadow map
+ * (`features.shadows.cascades > 0`). Point-light cube shadows stay legacy-only.
+ *
+ * `u_shadowMapNormalBias` (world units, three.js `shadow.normalBias`) offsets
+ * the receiver along its normal before the lookup; 0 keeps the legacy result.
+ */
+export declare const SHADOW_FORWARD_FACTOR_GLSL = "float a3dForwardShadowFactor(vec3 worldPosition, vec3 normal, vec3 lightDirection) {\n  if (u_shadowMapEnabled < 0.5) return 1.0;\n  vec4 lightPosition = u_shadowMapMatrix * vec4(worldPosition, 1.0);\n  vec3 projected = lightPosition.xyz / max(lightPosition.w, 0.0001);\n  vec2 uv = projected.xy * 0.5 + 0.5;\n  if (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) return 1.0;\n  vec3 receiverNormal = normalize(normal);\n  vec3 receiverLightDirection = lightDirection / max(length(lightDirection), 0.0001);\n  float normalDotLight = clamp(abs(dot(receiverNormal, receiverLightDirection)), 0.0, 1.0);\n  float slopeTangent = min(sqrt(max(1.0 - normalDotLight * normalDotLight, 0.0)) / max(normalDotLight, 0.05), 8.0);\n  float slopeTexelBias = slopeTangent * u_shadowMapSlopeBias * max(u_shadowMapTexelSize.x, u_shadowMapTexelSize.y);\n  float projectedDepth = projected.z * 0.5 + 0.5;\n  float shadowed = 0.0;\n  float totalWeight = 0.0;\n  int sampleCount = clamp(int(u_shadowPcfSampleCount), 1, 32);\n  for (int i = 0; i < 32; ++i) {\n    if (i >= sampleCount) break;\n    vec4 sampleData = u_shadowPcfSamples[i];\n    float weight = max(sampleData.z, 0.0);\n    vec2 offset = sampleData.xy * u_shadowMapTexelSize;\n    float storedDepth = texture(u_shadowMapTexture, uv + offset).r;\n    float sampleTexelDistance = max(1.0, length(sampleData.xy));\n    float receiverDepth = projectedDepth - u_shadowMapBias - slopeTexelBias * sampleTexelDistance;\n    shadowed += (receiverDepth > storedDepth ? 1.0 : 0.0) * weight;\n    totalWeight += weight;\n  }\n  float occlusion = totalWeight > 0.0 ? shadowed / totalWeight : 0.0;\n  return mix(1.0, 1.0 - occlusion, clamp(u_shadowMapStrength, 0.0, 1.0));\n}";
+export declare const SHADOW_FORWARD_CHUNK_GLSL = "\nuniform sampler2D u_shadowMapTexture;\nuniform float u_shadowMapEnabled;\nuniform mat4 u_shadowMapMatrix;\nuniform float u_shadowMapStrength;\nuniform float u_shadowMapBias;\nuniform float u_shadowMapSlopeBias;\nuniform vec2 u_shadowMapTexelSize;\nuniform float u_shadowPcfSampleCount;\nuniform vec4 u_shadowPcfSamples[32];\nuniform float u_shadowMapNormalBias;\n\nfloat a3dForwardShadowFactor(vec3 worldPosition, vec3 normal, vec3 lightDirection) {\n  if (u_shadowMapEnabled < 0.5) return 1.0;\n  vec4 lightPosition = u_shadowMapMatrix * vec4(worldPosition, 1.0);\n  vec3 projected = lightPosition.xyz / max(lightPosition.w, 0.0001);\n  vec2 uv = projected.xy * 0.5 + 0.5;\n  if (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) return 1.0;\n  vec3 receiverNormal = normalize(normal);\n  vec3 receiverLightDirection = lightDirection / max(length(lightDirection), 0.0001);\n  float normalDotLight = clamp(abs(dot(receiverNormal, receiverLightDirection)), 0.0, 1.0);\n  float slopeTangent = min(sqrt(max(1.0 - normalDotLight * normalDotLight, 0.0)) / max(normalDotLight, 0.05), 8.0);\n  float slopeTexelBias = slopeTangent * u_shadowMapSlopeBias * max(u_shadowMapTexelSize.x, u_shadowMapTexelSize.y);\n  float projectedDepth = projected.z * 0.5 + 0.5;\n  float shadowed = 0.0;\n  float totalWeight = 0.0;\n  int sampleCount = clamp(int(u_shadowPcfSampleCount), 1, 32);\n  for (int i = 0; i < 32; ++i) {\n    if (i >= sampleCount) break;\n    vec4 sampleData = u_shadowPcfSamples[i];\n    float weight = max(sampleData.z, 0.0);\n    vec2 offset = sampleData.xy * u_shadowMapTexelSize;\n    float storedDepth = texture(u_shadowMapTexture, uv + offset).r;\n    float sampleTexelDistance = max(1.0, length(sampleData.xy));\n    float receiverDepth = projectedDepth - u_shadowMapBias - slopeTexelBias * sampleTexelDistance;\n    shadowed += (receiverDepth > storedDepth ? 1.0 : 0.0) * weight;\n    totalWeight += weight;\n  }\n  float occlusion = totalWeight > 0.0 ? shadowed / totalWeight : 0.0;\n  return mix(1.0, 1.0 - occlusion, clamp(u_shadowMapStrength, 0.0, 1.0));\n}\n\n// Legacy gate (ShaderLibraryCore light loop): spotShadowLayer.z marks the\n// shadow-casting light; directional (kind 0) and spot (kind 2) sample the\n// forward map, point (kind 1) and rect (> 2.5, packed z = 0) do not.\nfloat a3dForwardLightShadow(float kind, float castsShadow, vec3 worldPosition, vec3 normal, vec3 lightDirection) {\n  if (castsShadow < 0.5 || (kind > 0.5 && kind < 1.5) || kind > 2.5) return 1.0;\n  vec3 offsetPosition = worldPosition + normalize(normal) * u_shadowMapNormalBias;\n  return a3dForwardShadowFactor(offsetPosition, normal, lightDirection);\n}\n";
+//# sourceMappingURL=shadow_forward.glsl.d.ts.map

package/dist/program/chunks/shadow_forward.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadow_forward.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/program/chunks/shadow_forward.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,eAAO,MAAM,0BAA0B,irDA4BrC,CAAC;AAEH,eAAO,MAAM,yBAAyB,0mFAsBrC,CAAC"}

package/dist/program/chunks/shadow_forward.glsl.js

@@ -0,0 +1,73 @@
+/**
+ * `shadow_forward` chunk — directional/spot shadow-map receive for the
+ * generated forward program (#1225).
+ *
+ * The generated program (A3D_QR_CORE, default-on since #1238) replaced the
+ * legacy `aura3d/pbr-direct` shader for allow-listed materials, but its
+ * `fragment:lights` loop never sampled a shadow map: `forward/Lighting.ts`
+ * only binds `u_shadowMap*` when the program reflects them, so the bridged
+ * prd02 cascade (and the flag-off legacy map) was dropped and every capture
+ * was byte-identical to its no-shadows control.
+ *
+ * This chunk declares the legacy forward uniforms and the legacy
+ * `a3dForwardShadowFactor`, text-identical to ShaderLibraryCore.ts (a unit
+ * test pins the two), so the bound map is sampled exactly like the legacy
+ * shader does. Emitted only when the draw has a shadow map
+ * (`features.shadows.cascades > 0`). Point-light cube shadows stay legacy-only.
+ *
+ * `u_shadowMapNormalBias` (world units, three.js `shadow.normalBias`) offsets
+ * the receiver along its normal before the lookup; 0 keeps the legacy result.
+ */
+export const SHADOW_FORWARD_FACTOR_GLSL = /* glsl */ `float a3dForwardShadowFactor(vec3 worldPosition, vec3 normal, vec3 lightDirection) {
+  if (u_shadowMapEnabled < 0.5) return 1.0;
+  vec4 lightPosition = u_shadowMapMatrix * vec4(worldPosition, 1.0);
+  vec3 projected = lightPosition.xyz / max(lightPosition.w, 0.0001);
+  vec2 uv = projected.xy * 0.5 + 0.5;
+  if (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) return 1.0;
+  vec3 receiverNormal = normalize(normal);
+  vec3 receiverLightDirection = lightDirection / max(length(lightDirection), 0.0001);
+  float normalDotLight = clamp(abs(dot(receiverNormal, receiverLightDirection)), 0.0, 1.0);
+  float slopeTangent = min(sqrt(max(1.0 - normalDotLight * normalDotLight, 0.0)) / max(normalDotLight, 0.05), 8.0);
+  float slopeTexelBias = slopeTangent * u_shadowMapSlopeBias * max(u_shadowMapTexelSize.x, u_shadowMapTexelSize.y);
+  float projectedDepth = projected.z * 0.5 + 0.5;
+  float shadowed = 0.0;
+  float totalWeight = 0.0;
+  int sampleCount = clamp(int(u_shadowPcfSampleCount), 1, 32);
+  for (int i = 0; i < 32; ++i) {
+    if (i >= sampleCount) break;
+    vec4 sampleData = u_shadowPcfSamples[i];
+    float weight = max(sampleData.z, 0.0);
+    vec2 offset = sampleData.xy * u_shadowMapTexelSize;
+    float storedDepth = texture(u_shadowMapTexture, uv + offset).r;
+    float sampleTexelDistance = max(1.0, length(sampleData.xy));
+    float receiverDepth = projectedDepth - u_shadowMapBias - slopeTexelBias * sampleTexelDistance;
+    shadowed += (receiverDepth > storedDepth ? 1.0 : 0.0) * weight;
+    totalWeight += weight;
+  }
+  float occlusion = totalWeight > 0.0 ? shadowed / totalWeight : 0.0;
+  return mix(1.0, 1.0 - occlusion, clamp(u_shadowMapStrength, 0.0, 1.0));
+}`;
+export const SHADOW_FORWARD_CHUNK_GLSL = /* glsl */ `
+uniform sampler2D u_shadowMapTexture;
+uniform float u_shadowMapEnabled;
+uniform mat4 u_shadowMapMatrix;
+uniform float u_shadowMapStrength;
+uniform float u_shadowMapBias;
+uniform float u_shadowMapSlopeBias;
+uniform vec2 u_shadowMapTexelSize;
+uniform float u_shadowPcfSampleCount;
+uniform vec4 u_shadowPcfSamples[32];
+uniform float u_shadowMapNormalBias;
+
+${SHADOW_FORWARD_FACTOR_GLSL}
+
+// Legacy gate (ShaderLibraryCore light loop): spotShadowLayer.z marks the
+// shadow-casting light; directional (kind 0) and spot (kind 2) sample the
+// forward map, point (kind 1) and rect (> 2.5, packed z = 0) do not.
+float a3dForwardLightShadow(float kind, float castsShadow, vec3 worldPosition, vec3 normal, vec3 lightDirection) {
+  if (castsShadow < 0.5 || (kind > 0.5 && kind < 1.5) || kind > 2.5) return 1.0;
+  vec3 offsetPosition = worldPosition + normalize(normal) * u_shadowMapNormalBias;
+  return a3dForwardShadowFactor(offsetPosition, normal, lightDirection);
+}
+`;
+//# sourceMappingURL=shadow_forward.glsl.js.map

package/dist/program/chunks/shadow_forward.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadow_forward.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/program/chunks/shadow_forward.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,MAAM,CAAC,MAAM,0BAA0B,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BnD,CAAC;AAEH,MAAM,CAAC,MAAM,yBAAyB,GAAG,UAAU,CAAC;;;;;;;;;;;;EAYlD,0BAA0B;;;;;;;;;;CAU3B,CAAC"}

package/dist/quality/DeviceClasses.d.ts

@@ -0,0 +1,31 @@
+/**
+ * PRD 11 Phase 4 — versioned renderer-string → hardware-class table
+ * (PRD-11 §6.4 step 2, hardware classes per §17.1).
+ *
+ * One row per class; rows are evaluated top-down so the first matching tier
+ * wins (Ultra patterns are checked before High, and so on). Bump
+ * `DEVICE_CLASS_TABLE_VERSION` whenever a row changes so the persisted
+ * `aura3d.quality.v1` decision cache invalidates on table edits.
+ */
+import type { AuraQualityTier } from "../contracts/quality.js";
+export declare const DEVICE_CLASS_TABLE_VERSION = 2;
+/** Software rasterisers hit the hard floor before the class table (§6.4 step 1). */
+export declare const SOFTWARE_RENDERER_PATTERN: RegExp;
+export interface DeviceClassEntry {
+    readonly id: string;
+    readonly tier: AuraQualityTier;
+    readonly patterns: readonly RegExp[];
+}
+export declare const DEVICE_CLASSES: readonly DeviceClassEntry[];
+/** Safari's masked renderer string; §6.4 resolves it to Medium / confidence low. */
+export declare const MASKED_APPLE_RENDERER = "Apple GPU";
+export interface DeviceClassResult {
+    readonly tier: AuraQualityTier;
+    readonly matched: string | null;
+}
+/**
+ * Map a renderer string through the class table. `null`/unmatched returns
+ * `tier: "medium"` with `matched: null` — the caller decides the confidence.
+ */
+export declare function classifyRendererString(renderer: string | null): DeviceClassResult;
+//# sourceMappingURL=DeviceClasses.d.ts.map

package/dist/quality/DeviceClasses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeviceClasses.d.ts","sourceRoot":"","sources":["../../../../../packages/rendering/src/quality/DeviceClasses.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAI5D,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAE5C,oFAAoF;AACpF,eAAO,MAAM,yBAAyB,QAA8F,CAAC;AAErI,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAC/B,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;CACtC;AAED,eAAO,MAAM,cAAc,EAAE,SAAS,gBAAgB,EAiDrD,CAAC;AAEF,oFAAoF;AACpF,eAAO,MAAM,qBAAqB,cAAc,CAAC;AAEjD,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAC/B,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,iBAAiB,CAUjF"}

package/dist/quality/DeviceClasses.js

@@ -0,0 +1,83 @@
+/**
+ * PRD 11 Phase 4 — versioned renderer-string → hardware-class table
+ * (PRD-11 §6.4 step 2, hardware classes per §17.1).
+ *
+ * One row per class; rows are evaluated top-down so the first matching tier
+ * wins (Ultra patterns are checked before High, and so on). Bump
+ * `DEVICE_CLASS_TABLE_VERSION` whenever a row changes so the persisted
+ * `aura3d.quality.v1` decision cache invalidates on table edits.
+ */
+// v2 (11-S8): vendor marks such as `Iris(R) Xe`, `Arc(TM) A370M` and
+// `Adreno (TM) 730`, as real UNMASKED_RENDERER strings carry them, now match.
+export const DEVICE_CLASS_TABLE_VERSION = 2;
+/** Software rasterisers hit the hard floor before the class table (§6.4 step 1). */
+export const SOFTWARE_RENDERER_PATTERN = /SwiftShader|llvmpipe|Microsoft Basic Render|WARP|Software (Rendering|Adapter|Rasterizer)/i;
+export const DEVICE_CLASSES = [
+    {
+        id: "ultra",
+        tier: "ultra",
+        patterns: [
+            // RTX 4070+ / 50xx desktop only — a laptop suffix anywhere demotes to High.
+            /\bRTX\s*(40[7-9]\d|50\d\d)\b(?!.*(Laptop|Max-Q|Mobile))/i,
+            /\bM[34]\s*Max\b/i, // Apple M3 Max, M4 Max
+            /\bM\d\s*Ultra\b/i // M-series Ultra
+        ]
+    },
+    {
+        id: "high",
+        tier: "high",
+        patterns: [
+            /\bM[1-4]\s*Pro\b/i, // Apple M1-M4 Pro
+            /\bM[12]\s*Max\b/i, // Apple M1/M2 Max
+            /\bRTX\s*20\d\d/i, // RTX 20xx desktop
+            /\bRTX\s*30\d\d/i, // RTX 30xx desktop + laptop
+            /\bRTX\s*40\d\d\b.*(Laptop|Max-Q|Mobile)/i, // RTX 40xx laptop
+            /\bRadeon\s+(RX\s*)?[67]\d{3}M?\b/i, // RX 6000/7000 (RDNA2+)
+            /\bRDNA\s?[23]\b/i
+        ]
+    },
+    {
+        id: "medium",
+        tier: "medium",
+        patterns: [
+            /\bApple\s+M[1-4]\b(?!\s*(Pro|Max|Ultra))/i, // M1-M4 base
+            /\bIris(?:\(R\))?\s+Xe\b/i,
+            /\bArc(?:\(TM\))?\s+A?[357]\d\d[A-Z]?\b/i, // Intel Arc A3/A5/A7 integrated class
+            /\bAdreno\s*(?:\(TM\)\s*)?(?:6[5-9]\d|7\d\d)\b/i, // Adreno 650-799 (600-649 fall through to Low)
+            /\bApple\s+A1[4-9]\b/i, // Apple A14 and newer
+            /\bApple\s+A2\d\b/i
+        ]
+    },
+    {
+        id: "low",
+        tier: "low",
+        patterns: [
+            /\bUHD\b/i, // Intel UHD
+            /\bIntel\s+HD\b/i,
+            /\bHD\s+Graphics\b/i,
+            /\bAdreno\s*(?:\(TM\)\s*)?[56][0-4]\d\b/i, // Adreno 500-640
+            /\bMali[\s-]?G[57]\d\b/i, // Mali-G5x / G7x
+            /\bApple\s+A1[23]\b/i, // A12 / A13
+            /\bParavirtual\b/i // Apple Paravirtual device (CI runner)
+        ]
+    }
+];
+/** Safari's masked renderer string; §6.4 resolves it to Medium / confidence low. */
+export const MASKED_APPLE_RENDERER = "Apple GPU";
+/**
+ * Map a renderer string through the class table. `null`/unmatched returns
+ * `tier: "medium"` with `matched: null` — the caller decides the confidence.
+ */
+export function classifyRendererString(renderer) {
+    if (!renderer)
+        return { tier: "medium", matched: null };
+    for (const entry of DEVICE_CLASSES) {
+        for (const pattern of entry.patterns) {
+            if (pattern.test(renderer)) {
+                return { tier: entry.tier, matched: entry.id };
+            }
+        }
+    }
+    return { tier: "medium", matched: null };
+}
+//# sourceMappingURL=DeviceClasses.js.map

package/dist/quality/DeviceClasses.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeviceClasses.js","sourceRoot":"","sources":["../../../../../packages/rendering/src/quality/DeviceClasses.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,qEAAqE;AACrE,8EAA8E;AAC9E,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,CAAC;AAE5C,oFAAoF;AACpF,MAAM,CAAC,MAAM,yBAAyB,GAAG,2FAA2F,CAAC;AAQrI,MAAM,CAAC,MAAM,cAAc,GAAgC;IACzD;QACE,EAAE,EAAE,OAAO;QACX,IAAI,EAAE,OAAO;QACb,QAAQ,EAAE;YACR,4EAA4E;YAC5E,0DAA0D;YAC1D,kBAAkB,EAAc,uBAAuB;YACvD,kBAAkB,CAAc,iBAAiB;SAClD;KACF;IACD;QACE,EAAE,EAAE,MAAM;QACV,IAAI,EAAE,MAAM;QACZ,QAAQ,EAAE;YACR,mBAAmB,EAAa,kBAAkB;YAClD,kBAAkB,EAAc,kBAAkB;YAClD,iBAAiB,EAAe,mBAAmB;YACnD,iBAAiB,EAAe,4BAA4B;YAC5D,0CAA0C,EAAE,kBAAkB;YAC9D,mCAAmC,EAAE,wBAAwB;YAC7D,kBAAkB;SACnB;KACF;IACD;QACE,EAAE,EAAE,QAAQ;QACZ,IAAI,EAAE,QAAQ;QACd,QAAQ,EAAE;YACR,2CAA2C,EAAE,aAAa;YAC1D,0BAA0B;YAC1B,yCAAyC,EAAE,sCAAsC;YACjF,gDAAgD,EAAE,+CAA+C;YACjG,sBAAsB,EAAU,sBAAsB;YACtD,mBAAmB;SACpB;KACF;IACD;QACE,EAAE,EAAE,KAAK;QACT,IAAI,EAAE,KAAK;QACX,QAAQ,EAAE;YACR,UAAU,EAAsB,YAAY;YAC5C,iBAAiB;YACjB,oBAAoB;YACpB,yCAAyC,EAAE,iBAAiB;YAC5D,wBAAwB,EAAQ,iBAAiB;YACjD,qBAAqB,EAAW,YAAY;YAC5C,kBAAkB,CAAc,uCAAuC;SACxE;KACF;CACF,CAAC;AAEF,oFAAoF;AACpF,MAAM,CAAC,MAAM,qBAAqB,GAAG,WAAW,CAAC;AAOjD;;;GAGG;AACH,MAAM,UAAU,sBAAsB,CAAC,QAAuB;IAC5D,IAAI,CAAC,QAAQ;QAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;IACxD,KAAK,MAAM,KAAK,IAAI,cAAc,EAAE,CAAC;QACnC,KAAK,MAAM,OAAO,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;YACrC,IAAI,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;gBAC3B,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC;YACjD,CAAC;QACH,CAAC;IACH,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;AAC3C,CAAC"}

package/dist/quality/DeviceProbe.d.ts

@@ -0,0 +1,42 @@
+/**
+ * PRD 11 Phase 0 — `DeviceProbe` (C-28) for WebGL2 contexts.
+ *
+ * `probeWebGL2Device(gl, env?)` is the testable seam: `env` injects the
+ * navigator/screen/matchMedia surface so unit tests run without a DOM. The
+ * production caller is `createWebGL2DeviceProbe` in `webgl2/Probe.ts`, which
+ * passes no `env` and therefore reads the real globals.
+ *
+ * `gpuTimingBackendForDevice(device)` lazily creates one scoped GPU timing
+ * backend per device by looking up the `WebGL2DeviceHost` registered by
+ * `webgl2/Probe.ts` at construction time (PRD 11 §Phase 0; Q-01-2 asks lane 01
+ * to expose this on the interface eventually).
+ */
+import type { DeviceProbe } from "../contracts/device.js";
+import type { RenderDevice } from "../RenderDevice.js";
+import { type RendererGpuTimingBackend } from "../RendererTiming.js";
+export interface ProbeEnvironment {
+    readonly navigator?: {
+        readonly userAgent?: string;
+        readonly hardwareConcurrency?: number;
+        readonly deviceMemory?: number;
+        readonly userAgentData?: {
+            readonly mobile?: boolean;
+        };
+    } | null;
+    readonly screen?: {
+        readonly width: number;
+        readonly height: number;
+    } | null;
+    readonly devicePixelRatio?: number;
+    /** Pre-resolved `matchMedia("(pointer: coarse)")` result; a real browser supplies it. */
+    readonly coarsePointer?: boolean;
+}
+export declare function probeWebGL2Device(gl: WebGL2RenderingContext, env?: ProbeEnvironment): DeviceProbe;
+/**
+ * One scoped timing backend per device (query queues live on the backend, so
+ * it must be shared across frames). `null` for non-WebGL2 devices, devices
+ * whose probe reports `timerQuery === false`, or when the host seam is absent
+ * (the backend degrades to cpu-only rather than throwing).
+ */
+export declare function gpuTimingBackendForDevice(device: RenderDevice): RendererGpuTimingBackend | null;
+//# sourceMappingURL=DeviceProbe.d.ts.map

package/dist/quality/DeviceProbe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeviceProbe.d.ts","sourceRoot":"","sources":["../../../../../packages/rendering/src/quality/DeviceProbe.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAgC,KAAK,wBAAwB,EAAE,MAAM,mBAAmB,CAAC;AAGhG,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,SAAS,CAAC,EAAE;QACnB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAC5B,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC;QACtC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;QAC/B,QAAQ,CAAC,aAAa,CAAC,EAAE;YAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;SAAE,CAAC;KACxD,GAAG,IAAI,CAAC;IACT,QAAQ,CAAC,MAAM,CAAC,EAAE;QAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAC7E,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,yFAAyF;IACzF,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;CAClC;AA0BD,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,sBAAsB,EAAE,GAAG,CAAC,EAAE,gBAAgB,GAAG,WAAW,CA4BjG;AAID;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,YAAY,GAAG,wBAAwB,GAAG,IAAI,CAW/F"}

package/dist/quality/DeviceProbe.js

@@ -0,0 +1,83 @@
+/**
+ * PRD 11 Phase 0 — `DeviceProbe` (C-28) for WebGL2 contexts.
+ *
+ * `probeWebGL2Device(gl, env?)` is the testable seam: `env` injects the
+ * navigator/screen/matchMedia surface so unit tests run without a DOM. The
+ * production caller is `createWebGL2DeviceProbe` in `webgl2/Probe.ts`, which
+ * passes no `env` and therefore reads the real globals.
+ *
+ * `gpuTimingBackendForDevice(device)` lazily creates one scoped GPU timing
+ * backend per device by looking up the `WebGL2DeviceHost` registered by
+ * `webgl2/Probe.ts` at construction time (PRD 11 §Phase 0; Q-01-2 asks lane 01
+ * to expose this on the interface eventually).
+ */
+import { createWebGL2GpuTimingBackend } from "../RendererTiming.js";
+import { webgl2DeviceHost } from "../webgl2/Counters.js";
+function detectMobile(env) {
+    const nav = env === undefined
+        ? (typeof navigator !== "undefined" ? navigator : null)
+        : env.navigator ?? null;
+    const uaData = nav?.userAgentData;
+    if (uaData && typeof uaData.mobile === "boolean") {
+        return uaData.mobile;
+    }
+    const coarse = env === undefined
+        ? (typeof matchMedia === "function" ? matchMedia("(pointer: coarse)").matches : null)
+        : env.coarsePointer ?? null;
+    if (coarse !== null && coarse !== undefined) {
+        return coarse;
+    }
+    const ua = nav?.userAgent ?? "";
+    if (!ua)
+        return null;
+    return /Android|iPhone|iPad|iPod|Mobile/i.test(ua);
+}
+export function probeWebGL2Device(gl, env) {
+    const debugInfo = gl.getExtension("WEBGL_debug_renderer_info");
+    const nav = env === undefined
+        ? (typeof navigator !== "undefined" ? navigator : null)
+        : env.navigator ?? null;
+    const scr = env === undefined
+        ? (typeof screen !== "undefined" ? screen : null)
+        : env.screen ?? null;
+    const dpr = env?.devicePixelRatio
+        ?? (typeof globalThis !== "undefined" && "devicePixelRatio" in globalThis ? globalThis.devicePixelRatio : 1);
+    return {
+        backend: "webgl2",
+        rendererString: gl.getParameter(gl.RENDERER) ?? "",
+        unmaskedRenderer: debugInfo ? (gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL) ?? null) : null,
+        unmaskedVendor: debugInfo ? (gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL) ?? null) : null,
+        maxTextureSize: gl.getParameter(gl.MAX_TEXTURE_SIZE),
+        maxSamples: gl.getParameter(gl.MAX_SAMPLES),
+        floatColorBuffer: gl.getExtension("EXT_color_buffer_float") != null,
+        halfFloatColorBuffer: gl.getExtension("EXT_color_buffer_half_float") != null,
+        timerQuery: gl.getExtension("EXT_disjoint_timer_query_webgl2") != null,
+        parallelShaderCompile: gl.getExtension("KHR_parallel_shader_compile") != null,
+        multiDraw: gl.getExtension("WEBGL_multi_draw") != null,
+        devicePixelRatio: dpr,
+        screen: scr ? [scr.width, scr.height] : [0, 0],
+        hardwareConcurrency: nav?.hardwareConcurrency ?? null,
+        deviceMemoryGB: nav && "deviceMemory" in nav ? (nav.deviceMemory ?? null) : null,
+        mobile: detectMobile(env)
+    };
+}
+const gpuBackends = new WeakMap();
+/**
+ * One scoped timing backend per device (query queues live on the backend, so
+ * it must be shared across frames). `null` for non-WebGL2 devices, devices
+ * whose probe reports `timerQuery === false`, or when the host seam is absent
+ * (the backend degrades to cpu-only rather than throwing).
+ */
+export function gpuTimingBackendForDevice(device) {
+    if (gpuBackends.has(device)) {
+        return gpuBackends.get(device) ?? null;
+    }
+    let backend = null;
+    const host = webgl2DeviceHost(device);
+    if (host && device.probe?.timerQuery) {
+        backend = createWebGL2GpuTimingBackend(host.gl);
+    }
+    gpuBackends.set(device, backend);
+    return backend;
+}
+//# sourceMappingURL=DeviceProbe.js.map

package/dist/quality/DeviceProbe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeviceProbe.js","sourceRoot":"","sources":["../../../../../packages/rendering/src/quality/DeviceProbe.ts"],"names":[],"mappings":"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"}

package/dist/quality/FrameStats.d.ts

@@ -0,0 +1,62 @@
+/**
+ * PRD 11 Phase 0 — real `frameStatsSlot` provider (C-28).
+ *
+ * A fixed-capacity ring of per-frame samples. CPU fields are measured directly;
+ * GPU fields arrive 2-3 frames later from a scoped `RendererGpuTimingBackend`
+ * (TIMESTAMP_EXT query pairs in `RendererTiming.ts`) and are written back into
+ * the stored sample when `poll()` returns them. `gpuMs` stays `null` when no
+ * timer backend exists or a query is discarded after `GPU_DISJOINT_EXT`.
+ *
+ * `fps()` is the strict measured value (`null` before 30 samples, CONTRACTS
+ * C-28). `legacyFps()` reproduces the pre-QR engine estimator (`0` before 2
+ * samples) so lane 15's diagnostics/overlay can swap to it via Q-15-1 without
+ * reproducing the formula.
+ */
+import type { DeviceCounters, FrameStatsLike, FrameStatsSample } from "../contracts/device.js";
+import { type RendererGpuTimingBackend } from "../RendererTiming.js";
+export type FrameStatsPercentileField = "intervalMs" | "cpuFrameMs" | "cpuSubmitMs" | "gpuMs";
+export interface FrameStatsPercentiles {
+    readonly p50: number;
+    readonly p95: number;
+    readonly p99: number;
+    readonly max: number;
+}
+export declare class FrameStats implements FrameStatsLike {
+    private readonly ring;
+    private writeIndex;
+    private sampleCountValue;
+    private lastBeginTs;
+    private frameStart;
+    private submitStart;
+    private cpuScopes;
+    private openScopes;
+    private pendingGpu;
+    private frameToken;
+    private readonly gpu;
+    constructor(capacity?: number, gpu?: RendererGpuTimingBackend);
+    /** Number of live samples in the ring (≤ capacity). Test/diagnostic surface; not in FrameStatsLike. */
+    get samples(): number;
+    begin(ts: number): void;
+    end(): FrameStatsSample;
+    scope<T>(name: string, fn: () => T): T;
+    percentiles(field: FrameStatsPercentileField): FrameStatsPercentiles;
+    /** Measured fps: `1000 / mean(intervalMs)` over the newest 30 samples; `null` before 30 samples exist. */
+    fps(): number | null;
+    /**
+     * Pre-QR estimator semantics (Q-15-1): `1000 / mean(intervalMs)` over every
+     * non-zero interval in the ring, `0` before the second sample. Kept separate
+     * from `fps()` so callers pick honest-vs-legacy explicitly.
+     */
+    legacyFps(): number;
+    private tryBeginScope;
+    private pushSample;
+    private orderedSamples;
+    private drainGpu;
+}
+/**
+ * Difference between two counters snapshots, per measured field. Live gauges
+ * (`liveBuffers`, `liveVertexArrays`, `textureBytes`, `renderTargetBytes`) are
+ * carried through from `next` — a delta of a gauge is meaningless.
+ */
+export declare function diffDeviceCounters(previous: DeviceCounters, next: DeviceCounters): DeviceCounters;
+//# sourceMappingURL=FrameStats.d.ts.map

package/dist/quality/FrameStats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FrameStats.d.ts","sourceRoot":"","sources":["../../../../../packages/rendering/src/quality/FrameStats.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5F,OAAO,EAGL,KAAK,wBAAwB,EAE9B,MAAM,mBAAmB,CAAC;AAE3B,MAAM,MAAM,yBAAyB,GAAG,YAAY,GAAG,YAAY,GAAG,aAAa,GAAG,OAAO,CAAC;AAC9F,MAAM,WAAW,qBAAqB;IAAG,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CAAE;AAgBlI,qBAAa,UAAW,YAAW,cAAc;IAC/C,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA0C;IAC/D,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,WAAW,CAAuB;IAC1C,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,SAAS,CAA8B;IAC/C,OAAO,CAAC,UAAU,CAA2E;IAC7F,OAAO,CAAC,UAAU,CAAyB;IAC3C,OAAO,CAAC,UAAU,CAAuC;IACzD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAwC;gBAEhD,QAAQ,SAAM,EAAE,GAAG,CAAC,EAAE,wBAAwB;IAK1D,uGAAuG;IACvG,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAgBvB,GAAG,IAAI,gBAAgB;IAkCvB,KAAK,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC;IAatC,WAAW,CAAC,KAAK,EAAE,yBAAyB,GAAG,qBAAqB;IAapE,0GAA0G;IAC1G,GAAG,IAAI,MAAM,GAAG,IAAI;IAOpB;;;;OAIG;IACH,SAAS,IAAI,MAAM;IAUnB,OAAO,CAAC,aAAa;IASrB,OAAO,CAAC,UAAU;IAQlB,OAAO,CAAC,cAAc;IAWtB,OAAO,CAAC,QAAQ;CA4BjB;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,cAAc,EAAE,IAAI,EAAE,cAAc,GAAG,cAAc,CAajG"}