openplanr 2.2640.8 → 2.2640.9

package/lib/host-packages/cursor/openplanr/runtime/design/scripts/design-shared-protocol-contracts-75a938cc.mjs

@@ -0,0 +1,222 @@
+// packages/protocol/src/canonical-json.mjs
+var hasOwn = (value, key) => Object.hasOwn(value, key);
+function assertUnicodeScalarString(value, path) {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code >= 55296 && code <= 56319) {
+      const next = value.charCodeAt(index + 1);
+      if (!(next >= 56320 && next <= 57343)) {
+        throw new TypeError(`JCS cannot canonicalize a lone high surrogate at ${path}.`);
+      }
+      index += 1;
+    } else if (code >= 56320 && code <= 57343) {
+      throw new TypeError(`JCS cannot canonicalize a lone low surrogate at ${path}.`);
+    }
+  }
+}
+function serialize(value, path, seen) {
+  if (value === null) return "null";
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "string") {
+    assertUnicodeScalarString(value, path);
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new TypeError(`JCS requires a finite number at ${path}.`);
+    return JSON.stringify(value);
+  }
+  if (typeof value !== "object")
+    throw new TypeError(`JCS cannot canonicalize ${typeof value} at ${path}.`);
+  if (seen.has(value)) throw new TypeError(`JCS cannot canonicalize a cycle at ${path}.`);
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) {
+      const entries2 = [];
+      for (let index = 0; index < value.length; index += 1) {
+        if (!hasOwn(value, index))
+          throw new TypeError(`JCS cannot canonicalize a sparse array at ${path}[${index}].`);
+        entries2.push(serialize(value[index], `${path}[${index}]`, seen));
+      }
+      return `[${entries2.join(",")}]`;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+      throw new TypeError(`JCS requires a plain JSON object at ${path}.`);
+    }
+    const entries = Object.keys(value).sort().map((key) => {
+      assertUnicodeScalarString(key, `${path} key`);
+      return `${JSON.stringify(key)}:${serialize(value[key], `${path}.${key}`, seen)}`;
+    });
+    return `{${entries.join(",")}}`;
+  } finally {
+    seen.delete(value);
+  }
+}
+function canonicalizeJson(value) {
+  return serialize(value, "$", /* @__PURE__ */ new Set());
+}
+var SHA256_K = /* @__PURE__ */ new Int32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var rotr = (value, bits) => value >>> bits | value << 32 - bits;
+function sha256Hex(value) {
+  const candidate = typeof value === "string" ? new TextEncoder().encode(value) : value;
+  if (!ArrayBuffer.isView(candidate) || Object.prototype.toString.call(candidate) !== "[object Uint8Array]") {
+    throw new TypeError("sha256Hex expects a string or Uint8Array.");
+  }
+  const input = new Uint8Array(candidate.buffer, candidate.byteOffset, candidate.byteLength);
+  const paddedLength = Math.ceil((input.length + 9) / 64) * 64;
+  const bytes = new Uint8Array(paddedLength);
+  bytes.set(input);
+  bytes[input.length] = 128;
+  const view = new DataView(bytes.buffer);
+  const bitLength = BigInt(input.length) * 8n;
+  view.setUint32(paddedLength - 8, Number(bitLength >> 32n & 0xffffffffn));
+  view.setUint32(paddedLength - 4, Number(bitLength & 0xffffffffn));
+  let h0 = 1779033703;
+  let h1 = 3144134277;
+  let h2 = 1013904242;
+  let h3 = 2773480762;
+  let h4 = 1359893119;
+  let h5 = 2600822924;
+  let h6 = 528734635;
+  let h7 = 1541459225;
+  const words = new Int32Array(64);
+  for (let offset = 0; offset < bytes.length; offset += 64) {
+    for (let index = 0; index < 16; index += 1) words[index] = view.getUint32(offset + index * 4);
+    for (let index = 16; index < 64; index += 1) {
+      const s0 = rotr(words[index - 15], 7) ^ rotr(words[index - 15], 18) ^ words[index - 15] >>> 3;
+      const s1 = rotr(words[index - 2], 17) ^ rotr(words[index - 2], 19) ^ words[index - 2] >>> 10;
+      words[index] = words[index - 16] + s0 + words[index - 7] + s1 | 0;
+    }
+    let a = h0;
+    let b = h1;
+    let c = h2;
+    let d = h3;
+    let e = h4;
+    let f = h5;
+    let g = h6;
+    let h = h7;
+    for (let index = 0; index < 64; index += 1) {
+      const s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const choice = e & f ^ ~e & g;
+      const temp1 = h + s1 + choice + SHA256_K[index] + words[index] | 0;
+      const s0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const majority = a & b ^ a & c ^ b & c;
+      const temp2 = s0 + majority | 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + temp1 | 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 | 0;
+    }
+    h0 = h0 + a | 0;
+    h1 = h1 + b | 0;
+    h2 = h2 + c | 0;
+    h3 = h3 + d | 0;
+    h4 = h4 + e | 0;
+    h5 = h5 + f | 0;
+    h6 = h6 + g | 0;
+    h7 = h7 + h | 0;
+  }
+  return [h0, h1, h2, h3, h4, h5, h6, h7].map((part) => (part >>> 0).toString(16).padStart(8, "0")).join("");
+}
+function deepFreeze(value) {
+  if (value && typeof value === "object" && !Object.isFrozen(value)) {
+    for (const nested of Object.values(value)) deepFreeze(nested);
+    Object.freeze(value);
+  }
+  return value;
+}
+function assertPlainDataAt(value, label, depth, seen) {
+  if (depth > 64) throw new TypeError(`${label} exceeds the maximum nesting depth.`);
+  if (value === null || ["string", "boolean"].includes(typeof value)) return;
+  if (typeof value === "number" && Number.isFinite(value)) return;
+  if (typeof value !== "object" || seen.has(value))
+    throw new TypeError(`${label} must be finite, acyclic JSON.`);
+  if (!Array.isArray(value) && ![Object.prototype, null].includes(Object.getPrototypeOf(value)))
+    throw new TypeError(`${label} must contain only plain JSON objects.`);
+  seen.add(value);
+  for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+    if (["__proto__", "prototype", "constructor"].includes(key) || !Object.hasOwn(descriptor, "value"))
+      throw new TypeError(`${label} contains a forbidden property.`);
+    assertPlainDataAt(descriptor.value, label, depth + 1, seen);
+  }
+  seen.delete(value);
+}
+function assertPlainData(value, label) {
+  assertPlainDataAt(value, label, 0, /* @__PURE__ */ new Set());
+}
+
+export {
+  canonicalizeJson,
+  sha256Hex,
+  deepFreeze,
+  assertPlainData
+};

package/lib/host-packages/cursor/openplanr/runtime/design/scripts/design-upload-spool.mjs

@@ -0,0 +1,198 @@
+import {
+  uploadChunksFor
+} from "./design-chunked-workspace-client.mjs";
+import {
+  resourceSha256
+} from "./design-resource-pack.mjs";
+import {
+  ensurePrivateDirectory
+} from "./design-owner-custody.mjs";
+import {
+  assertLargeObjectContract
+} from "./design-shared-protocol-contracts-31a760fc.mjs";
+import {
+  canonicalizeJson
+} from "./design-shared-protocol-contracts-75a938cc.mjs";
+
+// packages/artifact/lib/artifact/upload-spool.mjs
+import {
+  closeSync,
+  constants,
+  existsSync,
+  fstatSync,
+  fsyncSync,
+  lstatSync,
+  openSync,
+  readSync,
+  writeFileSync
+} from "node:fs";
+import { dirname, join, resolve } from "node:path";
+function privateRead(path, limit) {
+  const fd = openSync(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+  try {
+    const stat = fstatSync(fd);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > limit || process.platform !== "win32" && (stat.mode & 63 || stat.uid !== process.getuid()))
+      throw new TypeError("Upload spool must contain bounded private regular files.");
+    const bytes = new Uint8Array(Math.min(limit + 1, stat.size + 1));
+    let size = 0;
+    while (size < bytes.byteLength) {
+      const count = readSync(fd, bytes, size, bytes.byteLength - size, null);
+      if (!count) break;
+      size += count;
+    }
+    const after = fstatSync(fd);
+    if (size !== stat.size || after.size !== stat.size || after.mtimeMs !== stat.mtimeMs || after.ctimeMs !== stat.ctimeMs) {
+      throw new TypeError("Upload spool changed during its bounded private read.");
+    }
+    return bytes.subarray(0, size);
+  } finally {
+    closeSync(fd);
+  }
+}
+function writePrivate(path, bytes) {
+  const fd = openSync(
+    path,
+    constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | (constants.O_NOFOLLOW ?? 0),
+    384
+  );
+  try {
+    writeFileSync(fd, bytes);
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+}
+function readPreparedUploadRequest(directory) {
+  directory = resolve(directory);
+  try {
+    lstatSync(directory);
+  } catch (cause) {
+    const error = new TypeError("Prepared upload spool is missing or inaccessible.");
+    if (cause?.code === "ENOENT") error.code = "ENOENT";
+    throw error;
+  }
+  ensurePrivateDirectory(directory, { label: "Upload" });
+  try {
+    const body = JSON.parse(
+      new TextDecoder("utf-8", { fatal: true }).decode(
+        privateRead(join(directory, "request.json"), 256 * 1024)
+      )
+    );
+    return assertLargeObjectContract(
+      body,
+      body?.manifest?.kind === "openplanr-company-resource-manifest" ? "company-resource-upload-prepare" : "encrypted-upload-prepare"
+    );
+  } catch (cause) {
+    const error = new TypeError("Prepared upload request is invalid or inaccessible.");
+    if (cause?.code === "ENOENT") error.code = "ENOENT";
+    throw error;
+  }
+}
+function spoolChunkReader(directory, body) {
+  assertLargeObjectContract(
+    body,
+    body?.manifest?.kind === "openplanr-company-resource-manifest" ? "company-resource-upload-prepare" : "encrypted-upload-prepare"
+  );
+  directory = resolve(directory);
+  ensurePrivateDirectory(directory, { label: "Upload" });
+  const saved = readPreparedUploadRequest(directory);
+  if (canonicalizeJson(saved) !== canonicalizeJson(body))
+    throw new TypeError("Upload spool request differs from owner custody.");
+  return async (index) => {
+    const expected = body.manifest.chunks[index];
+    if (!expected || expected.index !== index) throw new TypeError("Invalid spool chunk index.");
+    const bytes = privateRead(join(directory, `${index}.bin`), expected.byteLength);
+    if (bytes.byteLength !== expected.byteLength || await resourceSha256(bytes) !== expected.sha256)
+      throw new TypeError("Upload spool chunk is corrupt.");
+    return bytes;
+  };
+}
+var preparedUploadChunkReader = spoolChunkReader;
+async function persistPreparedUploadSpool(body, chunks, directory) {
+  assertLargeObjectContract(
+    body,
+    body?.manifest?.kind === "openplanr-company-resource-manifest" ? "company-resource-upload-prepare" : "encrypted-upload-prepare"
+  );
+  if (!Array.isArray(chunks) || chunks.length !== body.manifest.chunks.length)
+    throw new TypeError("Prepared upload chunk count differs.");
+  directory = resolve(directory);
+  ensurePrivateDirectory(directory, { label: "Upload" });
+  for (const part of body.manifest.chunks) {
+    const path2 = join(directory, `${part.index}.bin`), bytes = chunks[part.index];
+    if (!(bytes instanceof Uint8Array) || bytes.byteLength !== part.byteLength || await resourceSha256(bytes) !== part.sha256)
+      throw new TypeError("Prepared upload bytes differ.");
+    if (existsSync(path2)) {
+      const existing = privateRead(path2, part.byteLength);
+      if (existing.byteLength !== part.byteLength || await resourceSha256(existing) !== part.sha256)
+        throw new TypeError("Existing upload spool will not be overwritten.");
+    } else writePrivate(path2, bytes);
+  }
+  const path = join(directory, "request.json"), serialized = canonicalizeJson(body);
+  if (existsSync(path)) {
+    if (new TextDecoder("utf-8", { fatal: true }).decode(privateRead(path, 256 * 1024)) !== serialized)
+      throw new TypeError("Existing spool request will not be overwritten.");
+  } else writePrivate(path, new TextEncoder().encode(serialized));
+  for (const ancestor of [directory, dirname(directory)]) {
+    const fd = openSync(ancestor, "r");
+    try {
+      fsyncSync(fd);
+    } finally {
+      closeSync(fd);
+    }
+  }
+  return directory;
+}
+async function persistUploadSpool(custody, root) {
+  const body = custody.pendingCreate ?? (custody.pendingMutation?.action === "publish" ? custody.pendingMutation.body : null);
+  if (!body) return;
+  if (custody.spoolDirectory) {
+    const reader = spoolChunkReader(custody.spoolDirectory, body);
+    for (const part of body.manifest.chunks) await reader(part.index);
+    return custody.spoolDirectory;
+  }
+  const chunks = uploadChunksFor(custody);
+  if (!chunks)
+    throw new TypeError("The pending upload has no durable spool; restore its recovery package.");
+  const directory = await persistPreparedUploadSpool(
+    body,
+    chunks,
+    join(resolve(root), custody.id, body.operationId)
+  );
+  for (let ancestor = dirname(directory); ; ancestor = dirname(ancestor)) {
+    const fd = openSync(ancestor, "r");
+    try {
+      fsyncSync(fd);
+    } finally {
+      closeSync(fd);
+    }
+    if (ancestor === dirname(resolve(root))) break;
+  }
+  custody.spoolDirectory = directory;
+  return directory;
+}
+async function copyUploadSpool(custody, destination) {
+  const body = custody.pendingCreate ?? (custody.pendingMutation?.action === "publish" ? custody.pendingMutation.body : null);
+  if (!body) return null;
+  if (existsSync(destination)) throw new TypeError("Recovery upload directory already exists.");
+  const reader = spoolChunkReader(custody.spoolDirectory, body);
+  ensurePrivateDirectory(destination, { label: "Recovery upload" });
+  for (const part of body.manifest.chunks)
+    writePrivate(join(destination, `${part.index}.bin`), await reader(part.index));
+  writePrivate(join(destination, "request.json"), new TextEncoder().encode(canonicalizeJson(body)));
+  const fd = openSync(destination, "r");
+  try {
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+  return destination;
+}
+
+export {
+  readPreparedUploadRequest,
+  spoolChunkReader,
+  preparedUploadChunkReader,
+  persistPreparedUploadSpool,
+  persistUploadSpool,
+  copyUploadSpool
+};

package/lib/host-packages/cursor/openplanr/runtime/design/scripts/design.mjs

@@ -45,11 +45,17 @@ import {
   listDesignRevisions,
   readDesignRevision,
   readJson
-} from "./design-escape.mjs";
-import "./design-pako-esm.mjs";
+} from "./design-shared-artifact-support-dependencies-design-support-protocol-contracts-3d9b1a86.mjs";
+import "./design-encrypted-workspace-client.mjs";
+import "./design-upload-spool.mjs";
+import "./design-chunked-workspace-client.mjs";
+import "./design-resource-pack.mjs";
+import "./design-compression.mjs";
+import "./design-owner-custody.mjs";
+import "./design-runtime-home.mjs";
 import {
   acquireStartLock
-} from "./design-planr-home.mjs";
+} from "./design-loopback-server.mjs";
 import "./design-parse5-parser.mjs";
 import "./design-parse5-tokenizer.mjs";
 import "./design-entities.mjs";
@@ -57,8 +63,9 @@ import {
   ARTIFACT_ERROR_CODES,
   PipelineError,
   digestArtifactEnvelope
-} from "./design-artifact-sources.mjs";
-import "./design-bounded-json-data.mjs";
+} from "./design-shared-artifact-support-protocol-contracts-ea2cd15e.mjs";
+import "./design-shared-protocol-contracts-31a760fc.mjs";
+import "./design-shared-protocol-contracts-75a938cc.mjs";
 
 // packages/design/lib/design/utility.mjs
 import { spawn } from "node:child_process";

package/lib/host-packages/cursor/openplanr/runtime/design/scripts/runtime/packages/artifact/templates/artifact-review-stage.js.sources/01-module-runtime.js

@@ -0,0 +1,18 @@
+
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);