@fitzzero/quickdraw-core 5.1.1 → 5.1.3

package/dist/{chunk-2PWMUVC7.js → chunk-OCZJ4EYV.js}

@@ -1,3 +1,7 @@
+import {
+  ACCESS_LEVELS,
+  isAccessLevel
+} from "./chunk-AK23XSWD.js";
 import {
   hasJsonSchema,
   isStandardSchema,
@@ -7,7 +11,389 @@ import {
   INTERNAL_MESSAGE,
   QuickdrawError,
   isErrorCode
-} from "./chunk-4YO5H5ON.js";
+} from "./chunk-Q4OGQM5I.js";
+
+// src/server/access/levels.ts
+var RANK = Object.freeze({
+  Public: 0,
+  Read: 1,
+  Moderate: 2,
+  Admin: 3
+});
+function meetsLevel(level, required) {
+  if (level === null || level === void 0) {
+    return false;
+  }
+  return (RANK[level] ?? -1) >= RANK[required];
+}
+function maxLevel(a, b) {
+  const left = isAccessLevel(a) ? a : null;
+  const right = isAccessLevel(b) ? b : null;
+  if (left === null || right === null) {
+    return left ?? right;
+  }
+  return RANK[right] > RANK[left] ? right : left;
+}
+function levelsAtLeast(required) {
+  return ACCESS_LEVELS.filter((level) => RANK[level] >= RANK[required]);
+}
+function serviceGrant(principal, service) {
+  const grants = principal.serviceAccess;
+  if (grants === null || grants === void 0 || !Object.hasOwn(grants, service)) {
+    return void 0;
+  }
+  return grants[service];
+}
+
+// src/server/emit/tiers.ts
+var SUBSCRIBE_LEVEL = "Read";
+var SUBSCRIBER_LEVELS = Object.freeze([
+  "Read",
+  "Moderate",
+  "Admin"
+]);
+var NOTHING = Object.freeze(/* @__PURE__ */ new Set());
+function hiddenAt(fields, keys, level) {
+  const hidden = keys.filter((key) => {
+    const required = Object.hasOwn(fields, key) ? fields[key] : void 0;
+    return required !== void 0 && !meetsLevel(level, required);
+  });
+  return hidden.length === 0 ? NOTHING : Object.freeze(new Set(hidden));
+}
+function tiersOf(fields, keys) {
+  const byLevel = /* @__PURE__ */ new Map();
+  const labels = /* @__PURE__ */ new Map();
+  const hiding = (level) => {
+    let found = byLevel.get(level);
+    if (found === void 0) {
+      const set = hiddenAt(fields, keys, level);
+      const signature = [...set].join("\0");
+      const label = labels.get(signature) ?? String.fromCodePoint(97 + labels.size);
+      labels.set(signature, label);
+      found = { hidden: set, label };
+      byLevel.set(level, found);
+    }
+    return found;
+  };
+  const hidden = (level) => hiding(level).hidden;
+  const groups = /* @__PURE__ */ new Map();
+  for (const level of SUBSCRIBER_LEVELS) {
+    const set = hidden(level);
+    const signature = [...set].join("\0");
+    const group = groups.get(signature);
+    if (group === void 0) {
+      groups.set(signature, { levels: [level], hidden: set });
+    } else {
+      group.levels.push(level);
+    }
+  }
+  return Object.freeze({
+    tiered: keys.some((key) => Object.hasOwn(fields, key)),
+    hidden,
+    label: (level) => hiding(level).label,
+    groups: Object.freeze([...groups.values()].map((group) => Object.freeze(group)))
+  });
+}
+function strip(row, hidden) {
+  if (hidden.size === 0) {
+    return row;
+  }
+  const kept = {};
+  for (const [key, value] of Object.entries(row)) {
+    if (!hidden.has(key)) {
+      kept[key] = value;
+    }
+  }
+  return kept;
+}
+
+// src/server/emit/projection.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPlain(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return Array.isArray(value) || prototype === Object.prototype || prototype === null;
+}
+function referenced(node, root) {
+  const ref = node.$ref;
+  if (typeof ref !== "string") {
+    return node;
+  }
+  if (ref === "#") {
+    return root;
+  }
+  const match = /^#\/(definitions|\$defs)\/(.+)$/.exec(ref);
+  const defs = match === null ? void 0 : root[match[1] ?? ""];
+  const name = (match?.[2] ?? "").replaceAll("~1", "/").replaceAll("~0", "~");
+  const target = isRecord(defs) ? defs[name] : void 0;
+  return isRecord(target) ? target : void 0;
+}
+function pointerToken(name) {
+  return name.replaceAll("~", "~0").replaceAll("/", "~1");
+}
+function schemaKeys(schema) {
+  if (!hasJsonSchema(schema)) {
+    return void 0;
+  }
+  let json;
+  try {
+    json = schema["~standard"].jsonSchema.output({ target: "draft-07" });
+  } catch {
+    return void 0;
+  }
+  const described = isRecord(json) ? referenced(json, json) : void 0;
+  const properties = described?.properties;
+  return isRecord(properties) ? Object.keys(properties) : void 0;
+}
+var BRANCHES = ["anyOf", "oneOf", "allOf"];
+var UNREPRESENTABLE_AS_ANY = Object.freeze({ unrepresentable: "any" });
+function addBranchKeys(node, root, keys, seen) {
+  const target = isRecord(node) ? referenced(node, root) : void 0;
+  if (target === void 0 || seen.has(target)) {
+    return;
+  }
+  seen.add(target);
+  if (isRecord(target.properties)) {
+    for (const key of Object.keys(target.properties)) {
+      keys.add(key);
+    }
+  }
+  for (const keyword of BRANCHES) {
+    const members = target[keyword];
+    if (Array.isArray(members)) {
+      for (const member of members) {
+        addBranchKeys(member, root, keys, seen);
+      }
+    }
+  }
+}
+function inputKeys(schema) {
+  if (!hasJsonSchema(schema)) {
+    return void 0;
+  }
+  let json;
+  try {
+    json = schema["~standard"].jsonSchema.input({
+      target: "draft-07",
+      libraryOptions: UNREPRESENTABLE_AS_ANY
+    });
+  } catch {
+    return void 0;
+  }
+  if (!isRecord(json)) {
+    return void 0;
+  }
+  const keys = /* @__PURE__ */ new Set();
+  addBranchKeys(json, json, keys, /* @__PURE__ */ new Set());
+  return [...keys];
+}
+var OPTION_KEYS = /* @__PURE__ */ new Set(["keys", "select", "map"]);
+function checkKeyList(owner, keys, fail) {
+  const valid = Array.isArray(keys) && keys.every((key) => typeof key === "string" && key.length > 0) && new Set(keys).size === keys.length;
+  if (!valid) {
+    fail(`${owner}: keys must be a list of distinct field names`);
+  }
+  if (!keys.includes("id")) {
+    fail(`${owner}: keys must include "id"; every row is keyed by it`);
+  }
+  return keys;
+}
+function checkOption(owner, option, fail) {
+  if (option === void 0) {
+    return {};
+  }
+  if (!isRecord(option)) {
+    fail(`${owner} must be { keys?, select?, map? }`);
+  }
+  const unknownKey = Object.keys(option).find((key) => !OPTION_KEYS.has(key));
+  if (unknownKey !== void 0) {
+    fail(`${owner} has an unknown option "${unknownKey}"; the options are keys, select and map`);
+  }
+  if (option.select !== void 0 && !isRecord(option.select)) {
+    fail(`${owner}: select must be a select object, as in { id: true, labels: { select: ... } }`);
+  }
+  if (option.map !== void 0 && typeof option.map !== "function") {
+    fail(`${owner}: map must be a function of the row its select reads`);
+  }
+  return option;
+}
+function keysFor(name, schema, option, fail) {
+  const owner = `projection "${name}"`;
+  if (option.keys !== void 0) {
+    return checkKeyList(owner, option.keys, fail);
+  }
+  const keys = schemaKeys(schema);
+  if (keys === void 0) {
+    fail(
+      `${owner}: its schema cannot list its keys (it has no Standard JSON Schema the framework can read); use Zod 4.2 or later for it, or declare them with project: { ${name}: { keys: [...] } }`
+    );
+  }
+  return keys;
+}
+function compileOne(name, schema, option, fields, fail) {
+  const checked = checkOption(`projection "${name}"`, option, fail);
+  const keys = keysFor(name, schema, checked, fail);
+  const ordered = ["id", ...keys.filter((key) => key !== "id")];
+  const select = isRecord(checked.select) ? { id: true, ...checked.select } : Object.fromEntries(ordered.map((key) => [key, true]));
+  return Object.freeze({
+    name,
+    keys: Object.freeze(ordered),
+    select: Object.freeze(select),
+    map: checked.map,
+    tiers: tiersOf(fields, ordered)
+  });
+}
+function compileProjections(contract, option, fail) {
+  if (option !== void 0 && !isRecord(option)) {
+    fail("project must map projection names to { keys?, select?, map? }");
+  }
+  const options = option ?? {};
+  const schemas = new Map(Object.entries(contract.projections));
+  if (contract.entity !== void 0) {
+    schemas.set("entity", contract.entity);
+  }
+  const unknownName = Object.keys(options).find((name) => !schemas.has(name));
+  if (unknownName !== void 0) {
+    fail(
+      `project names "${unknownName}", which is not a projection of the contract; the projections are ${[...schemas.keys()].map((name) => `"${name}"`).join(", ") || "none"}`
+    );
+  }
+  const compiled = /* @__PURE__ */ new Map();
+  for (const [name, schema] of schemas) {
+    compiled.set(name, compileOne(name, schema, options[name], contract.fields, fail));
+  }
+  return compiled;
+}
+function projectedOutput(output, projections) {
+  if (typeof output === "string") {
+    const projection2 = projections.get(output);
+    return projection2 === void 0 ? void 0 : { projection: projection2, kind: "one" };
+  }
+  if (!("kind" in output)) {
+    return void 0;
+  }
+  const projection = projections.get(output.projection);
+  const kind = output.kind === "nullable" ? "nullable" : "list";
+  return projection === void 0 ? void 0 : { projection, kind };
+}
+function isoDates(value) {
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (!isPlain(value)) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(isoDates);
+  }
+  const copy = {};
+  for (const [key, item] of Object.entries(value)) {
+    copy[key] = isoDates(item);
+  }
+  return copy;
+}
+function pickKeys(row, keys) {
+  const picked = {};
+  for (const key of keys) {
+    if (Object.hasOwn(row, key)) {
+      picked[key] = isoDates(row[key]);
+    }
+  }
+  return picked;
+}
+function projectRow(projection, row) {
+  if (!isRecord(row)) {
+    return row;
+  }
+  const source = projection.map === void 0 ? row : projection.map(row);
+  return isRecord(source) ? pickKeys(source, projection.keys) : source;
+}
+function projectOutput(output, value) {
+  if (output.kind === "list") {
+    return Array.isArray(value) ? value.map((row) => projectRow(output.projection, row)) : value;
+  }
+  if (value === null && output.kind === "nullable") {
+    return null;
+  }
+  return projectRow(output.projection, value);
+}
+function rowIds(value) {
+  const rows = Array.isArray(value) ? value : [value];
+  const ids = [];
+  for (const row of rows) {
+    if (isRecord(row) && typeof row.id === "string" && row.id.length > 0) {
+      ids.push(row.id);
+    }
+  }
+  return ids;
+}
+function wholeView(value) {
+  return { key: "", strip: () => value };
+}
+async function readerView(output, value, levelsOf) {
+  const { tiers } = output.projection;
+  if (!tiers.tiered || value === null || value === void 0) {
+    return wholeView(value);
+  }
+  const ids = [...new Set(rowIds(value))];
+  const levels = ids.length === 0 ? /* @__PURE__ */ new Map() : await levelsOf(ids);
+  const levelOf = (row) => typeof row.id === "string" ? levels.get(row.id) ?? null : null;
+  const rows = Array.isArray(value) ? value : [value];
+  const key = rows.map((row) => isRecord(row) ? tiers.label(levelOf(row)) : "-").join("");
+  const one = (row) => isRecord(row) ? strip(row, tiers.hidden(levelOf(row))) : row;
+  return { key, strip: () => Array.isArray(value) ? value.map(one) : one(value) };
+}
+
+// src/server/service.ts
+var runtimes = /* @__PURE__ */ new WeakMap();
+function registerRuntime(service, runtime) {
+  runtimes.set(service, runtime);
+}
+function runtimeOf(service) {
+  return typeof service === "object" && service !== null ? runtimes.get(service) : void 0;
+}
+var handlerChecks = /* @__PURE__ */ new WeakMap();
+function checkWhenDefined(handler, check) {
+  handlerChecks.set(handler, check);
+}
+var grantsEditors = /* @__PURE__ */ new WeakSet();
+function markGrantsEditor(handler) {
+  grantsEditors.add(handler);
+}
+function editsGrants(handler) {
+  return grantsEditors.has(handler);
+}
+function handlerProblem(handler, service) {
+  return handlerChecks.get(handler)?.(service);
+}
+var servedChecks = /* @__PURE__ */ new WeakMap();
+function checkWhenServed(handler, check) {
+  servedChecks.set(handler, check);
+}
+function servedProblem(handler, served) {
+  return servedChecks.get(handler)?.(served);
+}
+function isKitHandler(handler) {
+  return handlerChecks.has(handler);
+}
+var rowChecked = /* @__PURE__ */ new WeakSet();
+function checksRowsItself(handler) {
+  rowChecked.add(handler);
+}
+function isRowChecked(handler) {
+  return rowChecked.has(handler);
+}
+var callerDependent = /* @__PURE__ */ new WeakSet();
+function dependsOnCaller(handler) {
+  callerDependent.add(handler);
+}
+function isCallerDependent(handler) {
+  return callerDependent.has(handler);
+}
 
 // src/server/caller.ts
 var CALLER_GRANTS = /* @__PURE__ */ new WeakMap();
@@ -60,6 +446,12 @@ async function withLoadedGrants(principal, grants) {
   }
   return { ...principal, serviceAccess: serviceAccess ?? {} };
 }
+async function withCallerGrants(principal, grants) {
+  if (principal === null || carriesGrants(principal) || grants === void 0) {
+    return principal;
+  }
+  return await withLoadedGrants(principal, grants);
+}
 function principalOfCalls(principal, grants) {
   if (principal === null || carriesGrants(principal) || grants === void 0) {
     return () => principal;
@@ -91,6 +483,7 @@ function principalOfCalls(principal, grants) {
 }
 function createCaller(resolve, principal, settings = {}) {
   const principalOfCall = principalOfCalls(principal, settings.grants);
+  const { mcp } = settings;
   return lazyMembers(
     (service) => lazyMembers((method) => async (input, options) => {
       const runAs = principalOfCall();
@@ -101,12 +494,51 @@ function createCaller(resolve, principal, settings = {}) {
         // Awaited only while grants load: a known principal is dispatched at once, as before.
         principal: runAs instanceof Promise ? await runAs : runAs,
         transport: "internal",
-        signal: bothSignals(settings.signal, options?.signal)
+        signal: bothSignals(settings.signal, options?.signal),
+        ...mcp === void 0 ? {} : { mcp }
       });
     })
   );
 }
 
+// src/server/access/kinds.ts
+function isKindList(value) {
+  return Array.isArray(value) && value.length > 0 && value.every((kind) => typeof kind === "string" && kind.length > 0);
+}
+function narrowKinds(value, above, fail) {
+  if (value === void 0) {
+    return above?.kinds;
+  }
+  if (!isKindList(value)) {
+    fail(
+      'kinds must be a non-empty list of principal kinds (strings), such as ["user"]; leave it out to admit every kind'
+    );
+  }
+  if (above?.kinds !== void 0) {
+    const { kinds, by } = above;
+    const wider = value.find((kind) => !kinds.includes(kind));
+    if (wider !== void 0) {
+      fail(
+        `kinds may only narrow the kinds ${by} admits (${kinds.join(", ")}), and "${wider}" is not one of them`
+      );
+    }
+  }
+  return Object.freeze([...new Set(value)]);
+}
+function checkKind(kinds, principal, what) {
+  if (kinds === void 0 || principal === null) {
+    return;
+  }
+  const { kind } = principal;
+  if (typeof kind === "string" && kinds.includes(kind)) {
+    return;
+  }
+  throw new QuickdrawError(
+    "FORBIDDEN",
+    kind === void 0 ? `${what} is not open to a principal without a kind` : `${what} is not open to principals of kind "${String(kind)}"`
+  );
+}
+
 // src/server/pipeline/errors.ts
 function cancelledError() {
   return new QuickdrawError("CANCELLED", "The call was cancelled");
@@ -147,7 +579,7 @@ function toQuickdrawError(error) {
 
 // src/server/pipeline/schemaOutput.ts
 var ANY = Object.freeze({ any: true, object: void 0, array: void 0 });
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isPlainObject(value) {
@@ -169,11 +601,11 @@ function follow(ref, root) {
     } catch {
       return void 0;
     }
-    node = isRecord(node) && Object.hasOwn(node, part) ? node[part] : void 0;
+    node = isRecord2(node) && Object.hasOwn(node, part) ? node[part] : void 0;
   }
   return node;
 }
-var BRANCHES = ["anyOf", "oneOf", "allOf"];
+var BRANCHES2 = ["anyOf", "oneOf", "allOf"];
 function hasAny(node, keywords) {
   return keywords.some((keyword) => node[keyword] !== void 0);
 }
@@ -222,7 +654,7 @@ var Compiler = class {
     if (value === void 0 || value === true) {
       return this.make(true);
     }
-    if (!isRecord(value)) {
+    if (!isRecord2(value)) {
       return this.make(false);
     }
     const known = this.nodes.get(value);
@@ -242,7 +674,7 @@ var Compiler = class {
       const target = follow($ref, this.root);
       node.members.push(target === void 0 ? this.make(true) : this.read(target));
     }
-    for (const keyword of BRANCHES) {
+    for (const keyword of BRANCHES2) {
       const members = json[keyword];
       if (!Array.isArray(members)) {
         continue;
@@ -280,14 +712,14 @@ var Compiler = class {
   }
   readObject(json) {
     const properties = /* @__PURE__ */ new Map();
-    if (isRecord(json.properties)) {
+    if (isRecord2(json.properties)) {
       for (const [key, schema] of Object.entries(json.properties)) {
         properties.set(key, this.read(schema));
       }
     }
     const patterns = [];
     let open = false;
-    if (isRecord(json.patternProperties)) {
+    if (isRecord2(json.patternProperties)) {
       for (const [source, schema] of Object.entries(json.patternProperties)) {
         const regex = patternOf(source);
         if (regex === void 0) {
@@ -491,7 +923,7 @@ function keyPaths(root) {
   }
   return paths;
 }
-var UNREPRESENTABLE_AS_ANY = Object.freeze({ unrepresentable: "any" });
+var UNREPRESENTABLE_AS_ANY2 = Object.freeze({ unrepresentable: "any" });
 function compileSchemaOutput(schema) {
   if (!hasJsonSchema(schema)) {
     return void 0;
@@ -500,12 +932,12 @@ function compileSchemaOutput(schema) {
   try {
     json = schema["~standard"].jsonSchema.output({
       target: "draft-07",
-      libraryOptions: UNREPRESENTABLE_AS_ANY
+      libraryOptions: UNREPRESENTABLE_AS_ANY2
     });
   } catch {
     return void 0;
   }
-  if (!isRecord(json)) {
+  if (!isRecord2(json)) {
     return void 0;
   }
   const compiler = new Compiler(json);
@@ -610,11 +1042,8 @@ function withRuntime(ctx, runtime, services) {
   return ctx;
 }
 var NEVER_ABORTED = new AbortController().signal;
-function notAvailable(member) {
-  return new QuickdrawError(
-    "INTERNAL",
-    `${member} needs a dispatcher: it calls through the dispatcher that runs the method`
-  );
+function notAvailable(member, why) {
+  return new QuickdrawError("INTERNAL", `${member} needs a dispatcher: ${why}`);
 }
 function untracked() {
 }
@@ -628,23 +1057,33 @@ var INSPECTED = /* @__PURE__ */ new Set([
   "$$typeof",
   "nodeType"
 ]);
-function unavailable(member) {
+function unavailable(member, why) {
   return new Proxy(Object.freeze({}), {
     get(_target, key) {
       if (typeof key === "symbol" || INSPECTED.has(key)) {
         return void 0;
       }
-      throw notAvailable(`${member}.${key}`);
+      throw notAvailable(`${member}.${key}`, why);
     }
   });
 }
-var SERVICES = unavailable("ctx.services");
+var SERVICES = unavailable(
+  "ctx.services",
+  "it calls through the dispatcher that runs the method"
+);
+var ACCESS = unavailable(
+  "ctx.access",
+  "it reads the access policies of the dispatcher that runs the method"
+);
 var NO_ROOMS = Object.freeze({
   join: () => false,
   leave: ((_room, target) => target === void 0 ? false : Promise.resolve()),
   emit: untracked,
   emitToUser: untracked,
-  size: () => 0
+  size: () => 0,
+  setHost: () => false,
+  hostOf: () => null,
+  clearHost: () => void 0
 });
 var NO_PRESENCE = Object.freeze({
   isOnline: () => Promise.resolve(false),
@@ -652,19 +1091,20 @@ var NO_PRESENCE = Object.freeze({
   count: () => Promise.resolve(0),
   users: () => Promise.resolve([])
 });
-function servicesOf(dispatch, principal) {
+function servicesOf(dispatch, principal, mcp) {
   if (dispatch === void 0) {
     return void 0;
   }
-  return (signal) => createCaller(() => dispatch, principal, { signal });
+  return (signal) => createCaller(() => dispatch, principal, { signal, mcp });
 }
 function createContext(fields, extend) {
-  const { kit, dispatch, ...own } = fields;
-  const services = servicesOf(dispatch, own.principal);
+  const { kit, dispatch, access, ...own } = fields;
+  const services = servicesOf(dispatch, own.principal, own.mcp);
   const base = Object.freeze({
     ...own,
     touch: own.touch ?? untracked,
     services: services?.(own.signal) ?? SERVICES,
+    access: access?.forCaller(own.principal) ?? ACCESS,
     rooms: own.rooms ?? NO_ROOMS,
     presence: own.presence ?? NO_PRESENCE
   });
@@ -678,8 +1118,57 @@ function withSignal(ctx, signal) {
   const next = services === void 0 ? { ...ctx, signal } : { ...ctx, signal, services: services(signal) };
   return withRuntime(Object.freeze(next), KIT_RUNTIMES.get(ctx), services);
 }
+var CALLER_MEMBERS = /* @__PURE__ */ new Set([
+  "principal",
+  "services",
+  "mcp",
+  "access"
+]);
+function watchCallerReads(ctx, onRead) {
+  const watched = new Proxy(ctx, {
+    get(target, key, receiver) {
+      if (CALLER_MEMBERS.has(key)) {
+        onRead(key);
+      }
+      return Reflect.get(target, key, receiver);
+    }
+  });
+  return withRuntime(watched, KIT_RUNTIMES.get(ctx), SERVICE_CALLERS.get(ctx));
+}
 
 export {
+  meetsLevel,
+  maxLevel,
+  levelsAtLeast,
+  serviceGrant,
+  SUBSCRIBE_LEVEL,
+  SUBSCRIBER_LEVELS,
+  strip,
+  referenced,
+  pointerToken,
+  inputKeys,
+  compileProjections,
+  projectedOutput,
+  pickKeys,
+  projectRow,
+  projectOutput,
+  wholeView,
+  readerView,
+  registerRuntime,
+  runtimeOf,
+  checkWhenDefined,
+  markGrantsEditor,
+  editsGrants,
+  handlerProblem,
+  checkWhenServed,
+  servedProblem,
+  isKitHandler,
+  checksRowsItself,
+  isRowChecked,
+  dependsOnCaller,
+  isCallerDependent,
+  narrowKinds,
+  checkKind,
   cancelledError,
   timeoutError,
   throwIfCancelled,
@@ -693,10 +1182,12 @@ export {
   setCallerGrants,
   callerGrantsOf,
   lazyMembers,
+  withCallerGrants,
   createCaller,
   kitRuntimeOf,
   NEVER_ABORTED,
   createContext,
-  withSignal
+  withSignal,
+  watchCallerReads
 };
-//# sourceMappingURL=chunk-2PWMUVC7.js.map
+//# sourceMappingURL=chunk-OCZJ4EYV.js.map