@wix/himalaya-cli 0.877.0 → 0.879.0

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/stdlib/wix-sdk/blog-v3/src/extensions.d.ts

@@ -37,7 +37,18 @@ export interface WixGetPostRequest {
  * filter-by-id — a graceful degrade to the LIST projection (no body) that keeps
  * blog detail + saved screens rendering instead of erroring out. `queryPosts`'s
  * request type has no `fieldsets` field, so that fallback path cannot carry the
- * body. */
+ * body.
+ *
+ * When that fallback ALSO finds nothing (#2658) — a deleted post, or one this
+ * visitor may not see — we reject rather than resolve. `WixGetPostResponse.post`
+ * is non-optional, so returning `{ post: resp.posts?.[0] }` would hand callers an
+ * `undefined` the type promises is present, and the `post.title` access that type
+ * licenses throws a `TypeError` deep inside the caller — the exact hard error
+ * this fallback exists to prevent, and harder to diagnose than a clean rejection.
+ * Every call site rides its own rejection path (cached-post state, draft-only
+ * `catch`, or an `allSettled` filter), so rejecting is what routes them into the
+ * graceful degrade they already implement. The originating failure travels as
+ * `cause`, so the 404-vs-network distinction is not lost. */
 export declare function getPost(postId: string, req?: WixGetPostRequest): Promise<WixGetPostResponse>;
 export interface WixBlogCategory {
     id: string;

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/wix-blog.mjs

@@ -12,9 +12,13 @@ function getPost(postId, req = {}) {
   return wixCall(
     "GET",
     `/blog/v3/posts/${encodeURIComponent(postId)}` + query
-  ).catch(async () => {
+  ).catch(async (cause) => {
     const resp = await queryPosts({ query: { filter: { id: postId } } });
-    return { post: resp.posts?.[0] };
+    const post = resp.posts?.[0];
+    if (!post) {
+      throw new Error(`Blog post not found: ${postId}`, { cause });
+    }
+    return { post };
   });
 }
 function queryCategories(req = {}) {

package/dist/cli.mjs

@@ -37687,6 +37687,8 @@ var init_kits = __esm({
 // ../../core/dev-server/src/widgets.ts
 var widgets_exports = {};
 __export(widgets_exports, {
+  MAX_PRODUCE_CACHE_ENTRIES: () => MAX_PRODUCE_CACHE_ENTRIES,
+  PRODUCE_CACHE_TTL_MS: () => PRODUCE_CACHE_TTL_MS,
   WIDGET_BUDGET_MS: () => WIDGET_BUDGET_MS,
   buildViewSnapshot: () => buildViewSnapshot,
   buildWidgetSnapshot: () => buildWidgetSnapshot,
@@ -37694,6 +37696,7 @@ __export(widgets_exports, {
   extractWidgets: () => extractWidgets,
   freezeOverrideSnapshot: () => freezeOverrideSnapshot,
   frozenViewManifestEntries: () => frozenViewManifestEntries,
+  resetWidgetProduceCache: () => resetWidgetProduceCache,
   resetWidgetRealm: () => resetWidgetRealm,
   viewWidgetId: () => viewWidgetId,
   widgetRealm: () => widgetRealm
@@ -37722,6 +37725,84 @@ async function widgetRealm() {
 function resetWidgetRealm() {
   realmPromise = null;
 }
+function guestClock(clock) {
+  return clock === void 0 ? void 0 : Math.trunc(clock);
+}
+function serializedServices(produced) {
+  try {
+    return JSON.stringify(produced.services) ?? void 0;
+  } catch {
+    return void 0;
+  }
+}
+function resetWidgetProduceCache() {
+  produceCacheGeneration++;
+}
+function realmProduceCache(evaluator) {
+  const existing = produceCache.get(evaluator);
+  if (!existing) {
+    const fresh = { generation: produceCacheGeneration, entries: /* @__PURE__ */ new Map(), bytes: 0 };
+    produceCache.set(evaluator, fresh);
+    return fresh;
+  }
+  if (existing.generation !== produceCacheGeneration) {
+    existing.entries.clear();
+    existing.bytes = 0;
+    existing.generation = produceCacheGeneration;
+  }
+  return existing;
+}
+function dropEntry(cache, key2) {
+  const entry = cache.entries.get(key2);
+  if (!entry) return;
+  cache.entries.delete(key2);
+  cache.bytes -= entry.bytes;
+}
+function produceCacheKey(bundleJs, timeoutMs, clock) {
+  const digest2 = createHash14("sha256").update(bundleJs).digest("base64");
+  return `${timeoutMs}|${clock === void 0 ? "live" : Math.trunc(clock)}|${digest2}`;
+}
+function cachedProduce(evaluator, key2) {
+  const cache = realmProduceCache(evaluator);
+  const hit = cache.entries.get(key2);
+  if (!hit) return void 0;
+  if (Date.now() >= hit.expiresAt) {
+    dropEntry(cache, key2);
+    return void 0;
+  }
+  cache.entries.delete(key2);
+  cache.entries.set(key2, hit);
+  return { services: JSON.parse(hit.servicesJson), envelope: hit.envelope };
+}
+function rememberProduce(evaluator, key2, servicesJson, envelope, expiresAt) {
+  const bytes2 = envelope.length + servicesJson.length;
+  if (bytes2 > MAX_PRODUCE_ENTRY_BYTES) return;
+  const cache = realmProduceCache(evaluator);
+  dropEntry(cache, key2);
+  cache.entries.set(key2, { servicesJson, envelope, expiresAt, bytes: bytes2 });
+  cache.bytes += bytes2;
+  const over = () => cache.entries.size > MAX_PRODUCE_CACHE_ENTRIES || cache.bytes > MAX_PRODUCE_CACHE_BYTES;
+  if (!over()) return;
+  const now = Date.now();
+  for (const [k, entry] of [...cache.entries]) {
+    if (!over()) break;
+    if (k !== key2 && now >= entry.expiresAt) dropEntry(cache, k);
+  }
+  while (over()) {
+    const oldest = cache.entries.keys().next();
+    if (oldest.done || oldest.value === key2) break;
+    dropEntry(cache, oldest.value);
+  }
+}
+function reuseWindowMs(parsed) {
+  let window2 = PRODUCE_CACHE_TTL_MS;
+  for (const raw of [...parsed.widgets ?? [], ...parsed.views ?? []]) {
+    const ttl2 = parseJsonField(raw.refresh)?.ttlSeconds;
+    if (typeof ttl2 !== "number" || !Number.isFinite(ttl2) || ttl2 <= 0) continue;
+    window2 = Math.min(window2, ttl2 * 1e3);
+  }
+  return window2;
+}
 function viewRenderModes() {
   const out = {};
   for (const target of [...SURFACE_GROUPS, ...PREVIEW_SURFACES.map((s) => s.id)]) {
@@ -37924,7 +38005,30 @@ function parseJsonField(value) {
   }
 }
 async function extractWidgets(bundleJs, opts = {}) {
-  const services = {};
+  const evaluator = opts.evaluator ?? await widgetRealm();
+  const timeoutMs = opts.timeoutMs ?? WIDGET_BUDGET_MS;
+  const clock = guestClock(opts.clock);
+  const key2 = produceCacheKey(bundleJs, timeoutMs, clock);
+  const cached3 = cachedProduce(evaluator, key2);
+  const produced = cached3 ?? runProduce(evaluator, bundleJs, timeoutMs, clock);
+  let parsed;
+  try {
+    parsed = JSON.parse(produced.envelope);
+  } catch (err) {
+    throw new Error(`the widget producer's realm returned a malformed envelope: ${describeThrown(err)}`);
+  }
+  let services = produced.services;
+  if (!cached3) {
+    const servicesJson = serializedServices(produced);
+    if (servicesJson !== void 0) {
+      services = JSON.parse(servicesJson);
+      rememberProduce(evaluator, key2, servicesJson, produced.envelope, Date.now() + reuseWindowMs(parsed));
+    }
+  }
+  return interpretProduce(services, parsed);
+}
+function runProduce(evaluator, bundleJs, timeoutMs, clock) {
+  const services = /* @__PURE__ */ Object.create(null);
   let envelope;
   const inert = makeInert2();
   const himalayaTarget = {
@@ -37966,21 +38070,17 @@ async function extractWidgets(bundleJs, opts = {}) {
     }
   };
   sandbox.globalThis = sandbox;
-  const evaluator = opts.evaluator ?? await widgetRealm();
-  evaluator.run(widgetProgram(bundleJs, opts.clock), sandbox, {
-    timeoutMs: opts.timeoutMs ?? WIDGET_BUDGET_MS,
+  evaluator.run(widgetProgram(bundleJs, clock), sandbox, {
+    timeoutMs,
     filename: "widget-bundle.js",
     captureConsole: false
   });
   if (envelope === void 0) {
     throw new Error("the widget producer's realm returned no registrations envelope");
   }
-  let parsed;
-  try {
-    parsed = JSON.parse(envelope);
-  } catch (err) {
-    throw new Error(`the widget producer's realm returned a malformed envelope: ${describeThrown(err)}`);
-  }
+  return { services, envelope };
+}
+function interpretProduce(services, parsed) {
   const widgets = {};
   for (const raw of parsed.widgets ?? []) {
     widgets[String(raw.id)] = {
@@ -38239,7 +38339,7 @@ function freezeOverrideSnapshot(input, opts = {}) {
   }
   return snapshot2;
 }
-var MAX_TIMELINE_FRAMES, WIDGET_BUDGET_MS, realmPromise, CAPTURE_SLOT, READBACK_SERVICE;
+var MAX_TIMELINE_FRAMES, WIDGET_BUDGET_MS, realmPromise, PRODUCE_CACHE_TTL_MS, MAX_PRODUCE_CACHE_ENTRIES, MAX_PRODUCE_ENTRY_BYTES, MAX_PRODUCE_CACHE_BYTES, produceCache, produceCacheGeneration, CAPTURE_SLOT, READBACK_SERVICE;
 var init_widgets = __esm({
   "../../core/dev-server/src/widgets.ts"() {
     init_validator();
@@ -38247,6 +38347,12 @@ var init_widgets = __esm({
     MAX_TIMELINE_FRAMES = 48;
     WIDGET_BUDGET_MS = 5e3;
     realmPromise = null;
+    PRODUCE_CACHE_TTL_MS = 6e4;
+    MAX_PRODUCE_CACHE_ENTRIES = 2048;
+    MAX_PRODUCE_ENTRY_BYTES = 4 * 1024 * 1024;
+    MAX_PRODUCE_CACHE_BYTES = 64 * 1024 * 1024;
+    produceCache = /* @__PURE__ */ new WeakMap();
+    produceCacheGeneration = 0;
     CAPTURE_SLOT = "himi.widget.capture";
     READBACK_SERVICE = "himi.widget.readback";
   }

package/guides/sdk-reference.json

@@ -6590,7 +6590,7 @@
       {
         "name": "getPost",
         "kind": "function",
-        "jsdoc": "/** Fetch a single PUBLISHED post by id — GET /blog/v3/posts/{id}. The list\n * (queryPosts) returns published posts, so the detail reads them here (draft\n * ids are a different space — getDraftPost is for the edit/create flow).\n *\n * Body fieldsets (#826): Blog v3 `GET /posts/{id}` returns 200 but only the\n * LIST projection (title / excerpt / meta) unless the caller asks for the body —\n * the bare GET has NO `richContent` / `contentText`. So we request\n * RICH_CONTENT + CONTENT_TEXT by default and the article body loads on the happy\n * path; callers can override via `req.fieldsets`. (Supersedes the old #507 note:\n * the 502 this GET once returned for anonymous visitors is gone — it 200s now —\n * but a body-less 200 was never the \"body preserved whenever the backend is\n * healthy\" the earlier comment claimed; the body was simply never requested.)\n *\n * On any rejection (network / backend error) we still fall back to a queryPosts\n * filter-by-id — a graceful degrade to the LIST projection (no body) that keeps\n * blog detail + saved screens rendering instead of erroring out. `queryPosts`'s\n * request type has no `fieldsets` field, so that fallback path cannot carry the\n * body. */",
+        "jsdoc": "/** Fetch a single PUBLISHED post by id — GET /blog/v3/posts/{id}. The list\n * (queryPosts) returns published posts, so the detail reads them here (draft\n * ids are a different space — getDraftPost is for the edit/create flow).\n *\n * Body fieldsets (#826): Blog v3 `GET /posts/{id}` returns 200 but only the\n * LIST projection (title / excerpt / meta) unless the caller asks for the body —\n * the bare GET has NO `richContent` / `contentText`. So we request\n * RICH_CONTENT + CONTENT_TEXT by default and the article body loads on the happy\n * path; callers can override via `req.fieldsets`. (Supersedes the old #507 note:\n * the 502 this GET once returned for anonymous visitors is gone — it 200s now —\n * but a body-less 200 was never the \"body preserved whenever the backend is\n * healthy\" the earlier comment claimed; the body was simply never requested.)\n *\n * On any rejection (network / backend error) we still fall back to a queryPosts\n * filter-by-id — a graceful degrade to the LIST projection (no body) that keeps\n * blog detail + saved screens rendering instead of erroring out. `queryPosts`'s\n * request type has no `fieldsets` field, so that fallback path cannot carry the\n * body.\n *\n * When that fallback ALSO finds nothing (#2658) — a deleted post, or one this\n * visitor may not see — we reject rather than resolve. `WixGetPostResponse.post`\n * is non-optional, so returning `{ post: resp.posts?.[0] }` would hand callers an\n * `undefined` the type promises is present, and the `post.title` access that type\n * licenses throws a `TypeError` deep inside the caller — the exact hard error\n * this fallback exists to prevent, and harder to diagnose than a clean rejection.\n * Every call site rides its own rejection path (cached-post state, draft-only\n * `catch`, or an `allSettled` filter), so rejecting is what routes them into the\n * graceful degrade they already implement. The originating failure travels as\n * `cause`, so the 404-vs-network distinction is not lost. */",
         "decl": "export function getPost(\n  postId: string,\n  req: WixGetPostRequest = {},\n): Promise<WixGetPostResponse>;",
         "http": "GET /blog/v3/posts/{…}"
       },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/himalaya-cli",
-  "version": "0.877.0",
+  "version": "0.879.0",
   "type": "module",
   "description": "himi — the Himalaya authoring CLI. Build a Tier-5 content package on your own machine, push it to the production serve as a draft, preview it on web + Himi Player, and read worker logs back — the remote dev loop. Wraps @himalaya/serve-cli for transport.",
   "keywords": [
@@ -63,5 +63,5 @@
       "artifactId": "himalaya-cli"
     }
   },
-  "falconPackageHash": "165e76dc8fe6c80270e34398c2070b203234e75c6e6b748b88abb286"
+  "falconPackageHash": "cadb5d525c1bd00dfb5a1b90aeae24a17d6b94eb560176b0cb962516"
 }