openplanr 3.0.1 → 3.1.1

package/lib/host-packages/claude/openplanr/runtime/design/scripts/runtime/packages/artifact/templates/artifact-review-stage.js.sources/03-protocol-contracts.js

@@ -240,17 +240,179 @@
   };
   var FORMAT_DATE = /^\d{4}-\d{2}-\d{2}$/;
   var FORMAT_DATETIME = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/;
+  var SUPPORTED_FORMATS = /* @__PURE__ */ new Set(["date", "date-time"]);
+  var ANNOTATION_KEYWORDS = [
+    "$schema",
+    "$id",
+    "$defs",
+    "$comment",
+    "title",
+    "description",
+    "default",
+    "examples",
+    "deprecated",
+    "readOnly",
+    "writeOnly"
+  ];
+  var VALIDATION_KEYWORDS = [
+    "$ref",
+    "type",
+    "const",
+    "enum",
+    "minLength",
+    "maxLength",
+    "pattern",
+    "format",
+    "minimum",
+    "maximum",
+    "exclusiveMinimum",
+    "minItems",
+    "maxItems",
+    "prefixItems",
+    "items",
+    "uniqueItems",
+    "contains",
+    "minContains",
+    "maxContains",
+    "required",
+    "properties",
+    "additionalProperties",
+    "maxProperties",
+    "dependentRequired",
+    "unevaluatedProperties",
+    "oneOf",
+    "anyOf",
+    "allOf",
+    "if",
+    "then",
+    "else",
+    "not"
+  ];
+  var KNOWN_KEYWORDS = /* @__PURE__ */ new Set([...ANNOTATION_KEYWORDS, ...VALIDATION_KEYWORDS]);
+  var TYPE_NAMES = /* @__PURE__ */ new Set(["array", "boolean", "integer", "null", "number", "object", "string"]);
+  var isSchema = (value) => typeof value === "boolean" || value !== null && typeof value === "object" && !Array.isArray(value);
+  var isPlainObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+  var isCount = (value) => Number.isSafeInteger(value) && value >= 0;
+  var isUniqueStrings = (value) => Array.isArray(value) && value.every((item2) => typeof item2 === "string") && new Set(value).size === value.length;
+  var isSchemaArray = (value) => Array.isArray(value) && value.length > 0 && value.every(isSchema);
+  var isSchemaMap = (value) => isPlainObject(value) && Object.values(value).every(isSchema);
+  var compiledPatterns = /* @__PURE__ */ new Map();
+  var MAX_COMPILED_PATTERNS = 1024;
+  var tryCompilePattern = (source) => {
+    try {
+      return new RegExp(source);
+    } catch (error) {
+      if (error instanceof SyntaxError) return null;
+      throw error;
+    }
+  };
+  var compilePattern = (source) => {
+    if (!compiledPatterns.has(source)) {
+      if (compiledPatterns.size >= MAX_COMPILED_PATTERNS) compiledPatterns.clear();
+      compiledPatterns.set(source, tryCompilePattern(source));
+    }
+    return compiledPatterns.get(source) ?? null;
+  };
+  var describeValue = (value) => {
+    const text5 = String(JSON.stringify(value));
+    return text5.length > 80 ? `${text5.slice(0, 77)}...` : text5;
+  };
+  var KEYWORD_SHAPES = {
+    $ref: ["a string", (value) => typeof value === "string"],
+    $defs: ["an object of schemas", isSchemaMap],
+    type: [
+      "a type name or a non-empty array of unique type names",
+      (value) => typeof value === "string" && TYPE_NAMES.has(value) || isUniqueStrings(value) && value.length > 0 && value.every((name) => TYPE_NAMES.has(name))
+    ],
+    enum: ["an array", Array.isArray],
+    minLength: ["a non-negative integer", isCount],
+    maxLength: ["a non-negative integer", isCount],
+    pattern: [
+      "a valid regular expression string",
+      (value) => typeof value === "string" && compilePattern(value) !== null
+    ],
+    minimum: ["a finite number", Number.isFinite],
+    maximum: ["a finite number", Number.isFinite],
+    exclusiveMinimum: ["a finite number", Number.isFinite],
+    minItems: ["a non-negative integer", isCount],
+    maxItems: ["a non-negative integer", isCount],
+    prefixItems: ["a non-empty array of schemas", isSchemaArray],
+    items: ["a schema", isSchema],
+    uniqueItems: ["a boolean", (value) => typeof value === "boolean"],
+    contains: ["a schema", isSchema],
+    minContains: ["a non-negative integer", isCount],
+    maxContains: ["a non-negative integer", isCount],
+    required: ["an array of unique strings", isUniqueStrings],
+    properties: ["an object of schemas", isSchemaMap],
+    additionalProperties: ["a schema", isSchema],
+    maxProperties: ["a non-negative integer", isCount],
+    dependentRequired: [
+      "an object of unique string arrays",
+      (value) => isPlainObject(value) && Object.values(value).every(isUniqueStrings)
+    ],
+    unevaluatedProperties: ["a schema", isSchema],
+    oneOf: ["a non-empty array of schemas", isSchemaArray],
+    anyOf: ["a non-empty array of schemas", isSchemaArray],
+    allOf: ["a non-empty array of schemas", isSchemaArray],
+    if: ["a schema", isSchema],
+    then: ["a schema", isSchema],
+    else: ["a schema", isSchema],
+    not: ["a schema", isSchema]
+  };
   function resolveJsonPointer(root, reference) {
     if (reference === "#") return root;
     if (!reference.startsWith("#/")) return null;
     return reference.slice(2).split("/").map((part) => part.replaceAll("~1", "/").replaceAll("~0", "~")).reduce((value, part) => value?.[part], root);
   }
+  var wellFormedSchemas = /* @__PURE__ */ new WeakSet();
+  var isFrozenNode = (schema6) => Object.isFrozen(schema6) && Object.values(schema6).every(Object.isFrozen) && (!isPlainObject(schema6.dependentRequired) || Object.values(schema6.dependentRequired).every(Object.isFrozen));
+  var checkSchemaNode = (schema6, path, context) => {
+    if (wellFormedSchemas.has(schema6) || context.checkedSchemas.has(schema6)) return;
+    context.checkedSchemas.add(schema6);
+    const errorCount = context.schemaErrors.length;
+    for (const keyword of Object.keys(schema6)) {
+      if (!KNOWN_KEYWORDS.has(keyword) && !keyword.startsWith("x-")) {
+        context.schemaErrors.push({
+          path,
+          rule: "unsupported-keyword",
+          detail: `schema keyword '${keyword}' is not supported by this validator`
+        });
+      }
+    }
+    if (Object.hasOwn(schema6, "format") && !SUPPORTED_FORMATS.has(schema6.format)) {
+      context.schemaErrors.push({
+        path,
+        rule: "unsupported-format",
+        detail: `schema format ${JSON.stringify(schema6.format)} is not supported by this validator`
+      });
+    }
+    for (const [keyword, [expected, isValid]] of Object.entries(KEYWORD_SHAPES)) {
+      if (Object.hasOwn(schema6, keyword) && !isValid(schema6[keyword])) {
+        context.schemaErrors.push({
+          path,
+          rule: "schema",
+          detail: `schema keyword '${keyword}' must be ${expected}, got ${describeValue(schema6[keyword])}`
+        });
+      }
+    }
+    if (context.schemaErrors.length === errorCount && isFrozenNode(schema6)) {
+      wellFormedSchemas.add(schema6);
+    }
+  };
+  var reportReference = (schema6, path, detail, context) => {
+    if (context.reportedReferences.has(schema6)) return;
+    context.reportedReferences.add(schema6);
+    context.schemaErrors.push({ path, rule: "$ref", detail });
+  };
   var validateNode = (value, schema6, path, errs, context) => {
-    if (schema6 === true) return;
+    const evaluated = /* @__PURE__ */ new Set();
+    if (schema6 === true) return evaluated;
     if (schema6 === false) {
       errs.push({ path, rule: "schema:false", detail: "value not allowed" });
-      return;
+      return evaluated;
     }
+    if (!isSchema(schema6)) return evaluated;
+    checkSchemaNode(schema6, path, context);
     if (typeof schema6?.$ref === "string") {
       const reference = schema6.$ref;
       let resolved;
@@ -264,21 +426,23 @@
         nextRoot = result?.rootSchema ?? resolved;
         resolvedBase = result?.base ?? resolved?.$id ?? context.base;
       }
-      if (!resolved) {
-        errs.push({ path, rule: "$ref", detail: `could not resolve schema reference ${reference}` });
-        return;
+      if (!isSchema(resolved)) {
+        const detail = resolved === void 0 || resolved === null ? `could not resolve schema reference ${reference}` : `schema reference ${reference} resolved to ${typeOf(resolved)}, not a schema`;
+        reportReference(schema6, path, detail, context);
+        return evaluated;
       }
-      const referenceKey = `${context.base ?? "<root>"}:${reference}`;
+      const referenceKey = `${path} ${context.base ?? "<root>"}:${reference}`;
       if (context.referenceStack.includes(referenceKey)) {
-        errs.push({ path, rule: "$ref", detail: `circular schema reference ${reference}` });
-        return;
+        reportReference(schema6, path, `circular schema reference ${reference}`, context);
+        return evaluated;
       }
-      validateNode(value, resolved, path, errs, {
+      const referenced = validateNode(value, resolved, path, errs, {
         ...context,
         rootSchema: nextRoot,
         base: resolvedBase,
         referenceStack: [...context.referenceStack, referenceKey]
       });
+      for (const key of referenced) evaluated.add(key);
     }
     if (schema6.type !== void 0) {
       const types = Array.isArray(schema6.type) ? schema6.type : [schema6.type];
@@ -288,7 +452,7 @@
           rule: "type",
           detail: `expected ${types.join("|")}, got ${typeOf(value)}`
         });
-        return;
+        return evaluated;
       }
     }
     if (schema6.const !== void 0) {
@@ -324,22 +488,13 @@
           detail: `length ${value.length} > ${schema6.maxLength}`
         });
       }
-      if (typeof schema6.pattern === "string") {
-        try {
-          if (!new RegExp(schema6.pattern).test(value)) {
-            errs.push({
-              path,
-              rule: "pattern",
-              detail: `value ${JSON.stringify(value)} does not match /${schema6.pattern}/`
-            });
-          }
-        } catch (e) {
-          errs.push({
-            path,
-            rule: "pattern",
-            detail: `invalid regex /${schema6.pattern}/: ${e instanceof Error ? e.message : String(e)}`
-          });
-        }
+      const pattern = typeof schema6.pattern === "string" ? compilePattern(schema6.pattern) : null;
+      if (pattern && !pattern.test(value)) {
+        errs.push({
+          path,
+          rule: "pattern",
+          detail: `value ${JSON.stringify(value)} does not match /${schema6.pattern}/`
+        });
       }
       if (typeof schema6.format === "string") {
         if (schema6.format === "date" && !FORMAT_DATE.test(value)) {
@@ -364,6 +519,13 @@
       if (typeof schema6.maximum === "number" && value > schema6.maximum) {
         errs.push({ path, rule: "maximum", detail: `value ${value} > ${schema6.maximum}` });
       }
+      if (typeof schema6.exclusiveMinimum === "number" && value <= schema6.exclusiveMinimum) {
+        errs.push({
+          path,
+          rule: "exclusiveMinimum",
+          detail: `value ${value} <= ${schema6.exclusiveMinimum}`
+        });
+      }
     }
     if (Array.isArray(value)) {
       if (typeof schema6.minItems === "number" && value.length < schema6.minItems) {
@@ -427,8 +589,31 @@
           }
         }
       }
+      if (typeof schema6.maxProperties === "number" && Object.keys(value).length > schema6.maxProperties) {
+        errs.push({
+          path,
+          rule: "maxProperties",
+          detail: `property count ${Object.keys(value).length} > ${schema6.maxProperties}`
+        });
+      }
+      if (schema6.dependentRequired !== null && typeof schema6.dependentRequired === "object") {
+        for (const [trigger, dependencies] of Object.entries(schema6.dependentRequired)) {
+          if (!Object.hasOwn(value, trigger) || !Array.isArray(dependencies)) continue;
+          for (const dependency of dependencies) {
+            if (!Object.hasOwn(value, dependency)) {
+              errs.push({
+                path,
+                rule: "dependentRequired",
+                detail: `property '${trigger}' requires property '${dependency}'`
+              });
+            }
+          }
+        }
+      }
       const props = schema6.properties || {};
       for (const [k, v] of Object.entries(value)) {
+        if (Object.hasOwn(props, k)) evaluated.add(k);
+        else if (schema6.additionalProperties !== void 0) evaluated.add(k);
         if (!Object.hasOwn(props, k)) {
           if (schema6.additionalProperties === false) {
             errs.push({ path, rule: "additionalProperties", detail: `unknown property '${k}'` });
@@ -445,8 +630,11 @@
       let matched = 0;
       for (const sub of schema6.oneOf) {
         const e = [];
-        validateNode(value, sub, path, e, context);
-        if (e.length === 0) matched++;
+        const branch = validateNode(value, sub, path, e, context);
+        if (e.length === 0) {
+          matched++;
+          for (const key of branch) evaluated.add(key);
+        }
       }
       if (matched !== 1) {
         const titles = schema6.oneOf.map((s) => s.title || "(unnamed)").join(" | ");
@@ -461,8 +649,11 @@
       let matched = 0;
       for (const sub of schema6.anyOf) {
         const candidateErrors = [];
-        validateNode(value, sub, path, candidateErrors, context);
-        if (candidateErrors.length === 0) matched += 1;
+        const branch = validateNode(value, sub, path, candidateErrors, context);
+        if (candidateErrors.length === 0) {
+          matched += 1;
+          for (const key of branch) evaluated.add(key);
+        }
       }
       if (matched === 0) {
         const titles = schema6.anyOf.map((sub) => sub.title || "(unnamed)").join(" | ");
@@ -475,14 +666,21 @@
     }
     if (Array.isArray(schema6.allOf)) {
       for (const sub of schema6.allOf) {
-        validateNode(value, sub, path, errs, context);
+        for (const key of validateNode(value, sub, path, errs, context)) evaluated.add(key);
       }
     }
     if (schema6.if !== void 0) {
       const conditionErrors = [];
-      validateNode(value, schema6.if, path, conditionErrors, context);
-      const branch = conditionErrors.length === 0 ? schema6.then : schema6.else;
-      if (branch !== void 0) validateNode(value, branch, path, errs, context);
+      const condition = validateNode(value, schema6.if, path, conditionErrors, context);
+      const passed = conditionErrors.length === 0;
+      if (passed) for (const key of condition) evaluated.add(key);
+      const branch = passed ? schema6.then : schema6.else;
+      if (branch !== void 0) {
+        const branchErrors = [];
+        const branchEvaluated = validateNode(value, branch, path, branchErrors, context);
+        errs.push(...branchErrors);
+        if (branchErrors.length === 0) for (const key of branchEvaluated) evaluated.add(key);
+      }
     }
     if (schema6.not !== void 0) {
       const e = [];
@@ -491,6 +689,18 @@
         errs.push({ path, rule: "not", detail: "value matched a forbidden subschema" });
       }
     }
+    if (schema6.unevaluatedProperties !== void 0 && value !== null && typeof value === "object" && !Array.isArray(value)) {
+      for (const [k, v] of Object.entries(value)) {
+        if (evaluated.has(k)) continue;
+        if (schema6.unevaluatedProperties === false) {
+          errs.push({ path, rule: "unevaluatedProperties", detail: `unevaluated property '${k}'` });
+        } else {
+          validateNode(v, schema6.unevaluatedProperties, `${path}.${k}`, errs, context);
+        }
+        evaluated.add(k);
+      }
+    }
+    return evaluated;
   };
   var validateJson = (value, schema6, {
     resolveRef,
@@ -500,13 +710,26 @@
     )
   } = {}) => {
     const errs = [];
+    const schemaErrors = [];
+    if (!isSchema(schema6)) {
+      return [
+        {
+          path: "$",
+          rule: "schema",
+          detail: `expected a schema object or boolean, got ${typeOf(schema6)}`
+        }
+      ];
+    }
     validateNode(value, schema6, "$", errs, {
       rootSchema: schema6,
       resolveRef,
       base,
-      referenceStack: []
+      referenceStack: [],
+      schemaErrors,
+      checkedSchemas: /* @__PURE__ */ new WeakSet(),
+      reportedReferences: /* @__PURE__ */ new WeakSet()
     });
-    return errs;
+    return [...schemaErrors, ...errs];
   };
 
   // ../protocol/src/sharing-security-contracts.mjs

package/lib/host-packages/claude/openplanr/runtime/design/scripts/runtime/packages/artifact/templates/artifact-review-stage.js.sources.json

@@ -2,8 +2,8 @@
   "kind": "openplanr-runtime-asset-sources",
   "schemaVersion": "1.0.0",
   "asset": "artifact-review-stage.js",
-  "bytes": 519386,
-  "sha256": "f073ea1d7315f804b2a98f37ce4a0acd944d277fee3244b632ef7fe397b5f8ea",
+  "bytes": 528628,
+  "sha256": "8fe516175b5e135ea06b54a9a40776a140b27d6301d0a1530f953c4bcb7963a6",
   "scopes": [
     {
       "id": "bundle",
@@ -54,8 +54,8 @@
         "packages/protocol/src/studio-presentation-contracts.mjs",
         "packages/protocol/src/workspace-contracts.mjs"
       ],
-      "bytes": 172739,
-      "sha256": "2222cb9544f49c3af6ee1255085450119cb0973bba4b63c610964835c2ed0d54"
+      "bytes": 181981,
+      "sha256": "3494e8e8cd50ff596dc2c00cc4c02f6dd2f016de50e0fb1c284ac03b6470b19d"
     },
     {
       "path": "artifact-review-stage.js.sources/04-compression.js",

package/lib/host-packages/claude/openplanr/runtime/design/scripts/runtime/packages/design/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openplanr/design",
-  "version": "0.4.7",
+  "version": "0.4.8",
   "private": true,
   "type": "module",
   "description": "Canonical OpenPlanr design helpers and design-loop engine",
@@ -46,8 +46,8 @@
     "node": ">=22.13.0"
   },
   "dependencies": {
-    "@openplanr/artifact": "0.6.7",
-    "@openplanr/protocol": "0.12.0"
+    "@openplanr/artifact": "0.6.8",
+    "@openplanr/protocol": "0.13.0"
   },
   "scripts": {
     "test": "node --test --test-concurrency=2 tests/*.test.mjs",

package/lib/host-packages/claude/openplanr/runtime/design/scripts/runtime/packages/design/templates/studio/studio.js.sources/02-react.js

@@ -76,6 +76,7 @@
       var REACT_MEMO_TYPE = /* @__PURE__ */ Symbol.for("react.memo");
       var REACT_LAZY_TYPE2 = /* @__PURE__ */ Symbol.for("react.lazy");
       var REACT_ACTIVITY_TYPE = /* @__PURE__ */ Symbol.for("react.activity");
+      var REACT_VIEW_TRANSITION_TYPE = /* @__PURE__ */ Symbol.for("react.view_transition");
       var MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
       function getIteratorFn(maybeIterable) {
         if (null === maybeIterable || "object" !== typeof maybeIterable) return null;
@@ -263,19 +264,18 @@
       }
       function lazyInitializer(payload) {
         if (-1 === payload._status) {
-          var ctor = payload._result;
-          ctor = ctor();
-          ctor.then(
+          var ctor = payload._result, thenable = ctor();
+          thenable.then(
             function(moduleObject) {
               if (0 === payload._status || -1 === payload._status)
-                payload._status = 1, payload._result = moduleObject;
+                payload._status = 1, payload._result = moduleObject, void 0 === thenable.status && (thenable.status = "fulfilled", thenable.value = moduleObject);
             },
             function(error) {
               if (0 === payload._status || -1 === payload._status)
-                payload._status = 2, payload._result = error;
+                payload._status = 2, payload._result = error, void 0 === thenable.status && (thenable.status = "rejected", thenable.reason = error);
             }
           );
-          -1 === payload._status && (payload._status = 0, payload._result = ctor);
+          -1 === payload._status && (payload._status = 0, payload._result = thenable);
         }
         if (1 === payload._status) return payload._result.default;
         throw payload._result;
@@ -295,6 +295,27 @@
         }
         console.error(error);
       };
+      function startTransition(scope) {
+        var prevTransition = ReactSharedInternals.T, currentTransition = {};
+        currentTransition.types = null !== prevTransition ? prevTransition.types : null;
+        ReactSharedInternals.T = currentTransition;
+        try {
+          var returnValue = scope(), onStartTransitionFinish = ReactSharedInternals.S;
+          null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
+          "object" === typeof returnValue && null !== returnValue && "function" === typeof returnValue.then && returnValue.then(noop3, reportGlobalError);
+        } catch (error) {
+          reportGlobalError(error);
+        } finally {
+          null !== prevTransition && null !== currentTransition.types && (prevTransition.types = currentTransition.types), ReactSharedInternals.T = prevTransition;
+        }
+      }
+      function addTransitionType(type) {
+        var transition = ReactSharedInternals.T;
+        if (null !== transition) {
+          var transitionTypes = transition.types;
+          null === transitionTypes ? transition.types = [type] : -1 === transitionTypes.indexOf(type) && transitionTypes.push(type);
+        } else startTransition(addTransitionType.bind(null, type));
+      }
       var Children5 = {
         map: mapChildren,
         forEach: function(children, forEachFunc, forEachContext) {
@@ -334,6 +355,7 @@
       exports.PureComponent = PureComponent;
       exports.StrictMode = REACT_STRICT_MODE_TYPE;
       exports.Suspense = REACT_SUSPENSE_TYPE;
+      exports.ViewTransition = REACT_VIEW_TRANSITION_TYPE;
       exports.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = ReactSharedInternals;
       exports.__COMPILER_RUNTIME = {
         __proto__: null,
@@ -341,6 +363,7 @@
           return ReactSharedInternals.H.useMemoCache(size4);
         }
       };
+      exports.addTransitionType = addTransitionType;
       exports.cache = function(fn) {
         return function() {
           return fn.apply(null, arguments);
@@ -421,19 +444,7 @@
           compare: void 0 === compare ? null : compare
         };
       };
-      exports.startTransition = function(scope) {
-        var prevTransition = ReactSharedInternals.T, currentTransition = {};
-        ReactSharedInternals.T = currentTransition;
-        try {
-          var returnValue = scope(), onStartTransitionFinish = ReactSharedInternals.S;
-          null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
-          "object" === typeof returnValue && null !== returnValue && "function" === typeof returnValue.then && returnValue.then(noop3, reportGlobalError);
-        } catch (error) {
-          reportGlobalError(error);
-        } finally {
-          null !== prevTransition && null !== currentTransition.types && (prevTransition.types = currentTransition.types), ReactSharedInternals.T = prevTransition;
-        }
-      };
+      exports.startTransition = startTransition;
       exports.unstable_useCacheRefresh = function() {
         return ReactSharedInternals.H.useCacheRefresh();
       };
@@ -497,7 +508,7 @@
       exports.useTransition = function() {
         return ReactSharedInternals.H.useTransition();
       };
-      exports.version = "19.2.8";
+      exports.version = "19.3.0";
     }
   });
 
@@ -556,11 +567,13 @@
         findDOMNode: null
       };
       var REACT_PORTAL_TYPE = /* @__PURE__ */ Symbol.for("react.portal");
+      var REACT_RECOVERABLE_TYPE = /* @__PURE__ */ Symbol.for("react.recoverable");
+      var REACT_OPTIMISTIC_KEY = /* @__PURE__ */ Symbol.for("react.optimistic_key");
       function createPortal$1(children, containerInfo, implementation) {
         var key = 3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
         return {
           $$typeof: REACT_PORTAL_TYPE,
-          key: null == key ? null : "" + key,
+          key: null == key ? null : key === REACT_OPTIMISTIC_KEY ? REACT_OPTIMISTIC_KEY : "" + key,
           children,
           containerInfo,
           implementation
@@ -573,6 +586,9 @@
           return "use-credentials" === input ? input : "";
       }
       exports.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = Internals;
+      exports.browser = function(reason) {
+        return { $$typeof: REACT_RECOVERABLE_TYPE, _reason: reason };
+      };
       exports.createPortal = function(children, container) {
         var key = 2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : null;
         if (!container || 1 !== container.nodeType && 9 !== container.nodeType && 11 !== container.nodeType)
@@ -623,7 +639,8 @@
               Internals.d.M(href, {
                 crossOrigin,
                 integrity: "string" === typeof options2.integrity ? options2.integrity : void 0,
-                nonce: "string" === typeof options2.nonce ? options2.nonce : void 0
+                nonce: "string" === typeof options2.nonce ? options2.nonce : void 0,
+                fetchPriority: "string" === typeof options2.fetchPriority ? options2.fetchPriority : void 0
               });
             }
           } else null == options2 && Internals.d.M(href);
@@ -651,7 +668,9 @@
             Internals.d.m(href, {
               as: "string" === typeof options2.as && "script" !== options2.as ? options2.as : void 0,
               crossOrigin,
-              integrity: "string" === typeof options2.integrity ? options2.integrity : void 0
+              integrity: "string" === typeof options2.integrity ? options2.integrity : void 0,
+              nonce: "string" === typeof options2.nonce ? options2.nonce : void 0,
+              fetchPriority: "string" === typeof options2.fetchPriority ? options2.fetchPriority : void 0
             });
           } else Internals.d.m(href);
       };
@@ -667,7 +686,7 @@
       exports.useFormStatus = function() {
         return ReactSharedInternals.H.useHostTransitionStatus();
       };
-      exports.version = "19.2.8";
+      exports.version = "19.3.0";
     }
   });