nuxt-ai-ready 2.5.2 → 2.5.3

package/dist/module.json

@@ -4,7 +4,7 @@
     "nuxt": ">=4.0.0"
   },
   "configKey": "aiReady",
-  "version": "2.5.2",
+  "version": "2.5.3",
   "builder": {
     "@nuxt/module-builder": "1.0.3",
     "unbuild": "3.6.1"

package/dist/runtime/server/middleware/markdown.js

@@ -128,13 +128,13 @@ ${contentPage.markdown}`);
   if (!response.ok && response.status !== 404)
     return response;
   if (response.status === 404) {
-    setMarkdownHeaders(event, ctx);
+    setMarkdownHeaders(event, ctx, response.headers);
     setResponseStatus(event, 404);
     return notFoundMarkdown(ctx, canonicalUrl, buildFrontmatter);
   }
   const contentType = response.headers.get("content-type") || "";
   if (!contentType.includes("text/html")) {
-    setMarkdownHeaders(event, ctx);
+    setMarkdownHeaders(event, ctx, response.headers);
     setResponseStatus(event, 404);
     return notFoundMarkdown(ctx, canonicalUrl, buildFrontmatter);
   }
@@ -169,6 +169,6 @@ ${contentPage.markdown}`);
       additionalFrontmatter
     }
   );
-  setMarkdownHeaders(event, ctx);
+  setMarkdownHeaders(event, ctx, response.headers);
   return finalizeMarkdown(result.markdown);
 });

package/dist/runtime/server/utils/negotiation-response.d.ts

@@ -17,7 +17,7 @@ type NegotiationResponse = Awaited<ReturnType<typeof sendRedirect>> | undefined;
 export declare function setLinkHeader(event: H3Event, ctx: NegotiationContext, variant: 'html' | 'markdown'): void;
 export declare function setStatusAwareHeader(event: H3Event, ctx: NegotiationContext, variant: 'html' | 'markdown'): void;
 export declare function setUncacheableHeaders(event: H3Event): void;
-export declare function setMarkdownHeaders(event: H3Event, ctx: NegotiationContext): void;
+export declare function setMarkdownHeaders(event: H3Event, ctx: NegotiationContext, sourceHeaders?: Headers): void;
 /**
  * Site config is set up by a Nitro middleware. The early negotiation handler
  * runs in front of that middleware, so it must run the setup itself before it

package/dist/runtime/server/utils/negotiation-response.js

@@ -1,6 +1,6 @@
 import { createNitroRouteRuleMatcher } from "nuxtseo-shared/server";
 import { localAgentSkillArtifacts } from "#ai-ready-virtual/agent-skills.mjs";
-import { appendHeader, createError, getRequestHost, getResponseHeader, sendRedirect, setHeader } from "#nuxtseo/h3";
+import { appendHeader, createError, getHeader, getRequestHost, getResponseHeader, sendRedirect, setHeader } from "#nuxtseo/h3";
 import { useRuntimeConfig } from "#nuxtseo/nitro";
 import { withSiteUrl } from "#site-config/server/composables/utils";
 import initSiteConfig from "#site-config/server/middleware/init";
@@ -42,9 +42,24 @@ export function setUncacheableHeaders(event) {
       setHeader(event, header, "no-store");
   }
 }
-export function setMarkdownHeaders(event, ctx) {
+export function setMarkdownHeaders(event, ctx, sourceHeaders) {
   setHeader(event, "content-type", "text/markdown; charset=utf-8");
   setLinkHeader(event, ctx, "markdown");
+  const privateResponse = [
+    "cache-control",
+    "cdn-cache-control",
+    "cloudflare-cdn-cache-control",
+    "netlify-cdn-cache-control",
+    "vercel-cdn-cache-control",
+    "surrogate-control"
+  ].some((header) => {
+    const value = `${getResponseHeader(event, header) || ""},${sourceHeaders?.get(header) || ""}`;
+    return /(?:^|,)\s*(?:private|no-store|no-cache)\s*(?:,|=|$)/i.test(value);
+  });
+  if (getHeader(event, "cookie") || getHeader(event, "authorization") || getResponseHeader(event, "set-cookie") || sourceHeaders?.has("set-cookie") || privateResponse) {
+    setUncacheableHeaders(event);
+    return;
+  }
   const cacheHeaders = ctx.config.markdownCacheHeaders;
   if (cacheHeaders) {
     const { maxAge, swr } = cacheHeaders;

package/node_modules/mdream/node_modules/@emnapi/core/node_modules/@emnapi/wasi-threads/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Toyobayashi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/mdream/node_modules/@emnapi/core/node_modules/@emnapi/wasi-threads/README.md

@@ -0,0 +1,203 @@
+# @emnapi/wasi-threads
+
+This package makes [wasi-threads proposal](https://github.com/WebAssembly/wasi-threads) based WASI modules work in Node.js and browser.
+
+## Quick Start
+
+`index.html`
+
+```html
+<script src="./node_modules/@tybys/wasm-util/dist/wasm-util.js"></script>
+<script src="./node_modules/@emnapi/wasi-threads/dist/wasi-threads.js"></script>
+<script src="./index.js"></script>
+```
+
+If your application will block browser main thread (for example `pthread_join`), please run it in worker instead.
+
+```html
+<script>
+  // pthread_join (Atomics.wait) cannot be called in browser main thread
+  new Worker('./index.js')
+</script>
+```
+
+`index.js`
+
+```js
+const ENVIRONMENT_IS_NODE =
+  typeof process === 'object' && process !== null &&
+  typeof process.versions === 'object' && process.versions !== null &&
+  typeof process.versions.node === 'string';
+
+(function (main) {
+  if (ENVIRONMENT_IS_NODE) {
+    main(require)
+  } else {
+    if (typeof importScripts === 'function') {
+      importScripts('./node_modules/@tybys/wasm-util/dist/wasm-util.js')
+      importScripts('./node_modules/@emnapi/wasi-threads/dist/wasi-threads.js')
+    }
+    const nodeWasi = { WASI: globalThis.wasmUtil.WASI }
+    const nodeWorkerThreads = {
+      Worker: globalThis.Worker
+    }
+    const _require = function (request) {
+      if (request === 'node:wasi' || request === 'wasi') return nodeWasi
+      if (request === 'node:worker_threads' || request === 'worker_threads') return nodeWorkerThreads
+      if (request === '@emnapi/wasi-threads') return globalThis.wasiThreads
+      throw new Error('Can not find module: ' + request)
+    }
+    main(_require)
+  }
+})(async function (require) {
+  const { WASI } = require('wasi')
+  const { Worker } = require('worker_threads')
+  const { WASIThreads } = require('@emnapi/wasi-threads')
+
+  const wasi = new WASI({
+    version: 'preview1'
+  })
+  const wasiThreads = new WASIThreads({
+    wasi,
+
+    /**
+     * avoid Atomics.wait() deadlock during thread creation in browser
+     * see https://emscripten.org/docs/tools_reference/settings_reference.html#pthread-pool-size
+     */
+    reuseWorker: ENVIRONMENT_IS_NODE
+      ? false
+      : {
+          size: 4 /** greater than actual needs (2) */,
+          strict: true
+        },
+
+    /**
+     * Synchronous thread creation
+     * pthread_create will not return until thread worker actually starts
+     */
+    waitThreadStart: typeof window === 'undefined' ? 1000 : false,
+
+    onCreateWorker: () => {
+      return new Worker('./worker.js', {
+        execArgv: ['--experimental-wasi-unstable-preview1']
+      })
+    }
+  })
+  const memory = new WebAssembly.Memory({
+    initial: 16777216 / 65536,
+    maximum: 2147483648 / 65536,
+    shared: true
+  })
+  let input
+  const file = 'path/to/your/wasi-module.wasm'
+  try {
+    input = require('fs').readFileSync(require('path').join(__dirname, file))
+  } catch (err) {
+    const response = await fetch(file)
+    input = await response.arrayBuffer()
+  }
+  let { module, instance } = await WebAssembly.instantiate(input, {
+    env: { memory },
+    wasi_snapshot_preview1: wasi.wasiImport,
+    ...wasiThreads.getImportObject()
+  })
+
+  wasiThreads.setup(instance, module, memory)
+  await wasiThreads.preloadWorkers()
+
+  if (typeof instance.exports._start === 'function') {
+    return wasi.start(instance)
+  } else {
+    wasi.initialize(instance)
+    // instance.exports.exported_wasm_function()
+  }
+})
+```
+
+`worker.js`
+
+```js
+(function (main) {
+  const ENVIRONMENT_IS_NODE =
+    typeof process === 'object' && process !== null &&
+    typeof process.versions === 'object' && process.versions !== null &&
+    typeof process.versions.node === 'string'
+
+  if (ENVIRONMENT_IS_NODE) {
+    const _require = function (request) {
+      return require(request)
+    }
+
+    const _init = function () {
+      const nodeWorkerThreads = require('worker_threads')
+      const parentPort = nodeWorkerThreads.parentPort
+
+      parentPort.on('message', (data) => {
+        globalThis.onmessage({ data })
+      })
+
+      Object.assign(globalThis, {
+        self: globalThis,
+        require,
+        Worker: nodeWorkerThreads.Worker,
+        importScripts: function (f) {
+          (0, eval)(require('fs').readFileSync(f, 'utf8') + '//# sourceURL=' + f)
+        },
+        postMessage: function (msg) {
+          parentPort.postMessage(msg)
+        }
+      })
+    }
+
+    main(_require, _init)
+  } else {
+    importScripts('./node_modules/@tybys/wasm-util/dist/wasm-util.js')
+    importScripts('./node_modules/@emnapi/wasi-threads/dist/wasi-threads.js')
+
+    const nodeWasi = { WASI: globalThis.wasmUtil.WASI }
+    const _require = function (request) {
+      if (request === '@emnapi/wasi-threads') return globalThis.wasiThreads
+      if (request === 'node:wasi' || request === 'wasi') return nodeWasi
+      throw new Error('Can not find module: ' + request)
+    }
+    const _init = function () {}
+    main(_require, _init)
+  }
+})(function main (require, init) {
+  init()
+
+  const { WASI } = require('wasi')
+  const { ThreadMessageHandler, WASIThreads } = require('@emnapi/wasi-threads')
+
+  const handler = new ThreadMessageHandler({
+    async onLoad ({ wasmModule, wasmMemory }) {
+      const wasi = new WASI({
+        version: 'preview1'
+      })
+
+      const wasiThreads = new WASIThreads({
+        wasi,
+        childThread: true
+      })
+
+      const originalInstance = await WebAssembly.instantiate(wasmModule, {
+        env: {
+          memory: wasmMemory,
+        },
+        wasi_snapshot_preview1: wasi.wasiImport,
+        ...wasiThreads.getImportObject()
+      })
+
+      // must call `initialize` instead of `start` in child thread
+      const instance = wasiThreads.initialize(originalInstance, wasmModule, wasmMemory)
+
+      return { module: wasmModule, instance }
+    }
+  })
+
+  globalThis.onmessage = function (e) {
+    handler.handle(e)
+    // handle other messages
+  }
+})
+```

package/node_modules/mdream/node_modules/@emnapi/core/node_modules/@emnapi/wasi-threads/dist/wasi-threads.d.ts

@@ -0,0 +1,236 @@
+import type { Worker as Worker_2 } from 'worker_threads';
+
+export declare interface BaseOptions {
+    wasi: WASIInstance;
+    version?: 'preview1';
+    wasm64?: boolean;
+}
+
+export declare interface ChildThreadOptions extends BaseOptions {
+    childThread: true;
+    postMessage?: (data: any) => void;
+}
+
+export declare interface CleanupThreadPayload {
+    tid: number;
+}
+
+export declare interface CommandInfo<T extends CommandType> {
+    type: T;
+    payload: CommandPayloadMap[T];
+}
+
+export declare interface CommandPayloadMap {
+    load: LoadPayload;
+    loaded: LoadedPayload;
+    start: StartPayload;
+    'cleanup-thread': CleanupThreadPayload;
+    'terminate-all-threads': TerminateAllThreadsPayload;
+    'spawn-thread': SpawnThreadPayload;
+    'thread-error': ThreadErrorPayload;
+}
+
+export declare type CommandType = keyof CommandPayloadMap;
+
+export declare function createInstanceProxy(instance: WebAssembly.Instance, memory?: WebAssembly.Memory | (() => WebAssembly.Memory)): WebAssembly.Instance;
+
+export declare function isSharedArrayBuffer(value: any): value is SharedArrayBuffer;
+
+export declare function isTrapError(e: Error): e is WebAssembly.RuntimeError;
+
+export declare interface LoadedPayload {
+}
+
+export declare interface LoadPayload {
+    wasmModule: WebAssembly.Module;
+    wasmMemory: WebAssembly.Memory;
+    sab?: Int32Array;
+}
+
+export declare interface MainThreadBaseOptions extends BaseOptions {
+    waitThreadStart?: boolean | number;
+}
+
+export declare type MainThreadOptions = MainThreadOptionsWithThreadManager | MainThreadOptionsCreateThreadManager;
+
+export declare interface MainThreadOptionsCreateThreadManager extends MainThreadBaseOptions, ThreadManagerOptionsMain {
+}
+
+export declare interface MainThreadOptionsWithThreadManager extends MainThreadBaseOptions {
+    threadManager?: ThreadManager | (() => ThreadManager);
+}
+
+export declare interface MessageEventData<T extends CommandType> {
+    __emnapi__: CommandInfo<T>;
+}
+
+export declare interface ReuseWorkerOptions {
+    size: number;
+    strict?: boolean;
+}
+
+export declare interface SerializedError {
+    name: string;
+    message: string;
+    stack?: string;
+    cause?: unknown;
+}
+
+export declare interface SpawnThreadPayload {
+    startArg: number;
+    errorOrTid: number;
+}
+
+export declare interface StartPayload {
+    tid: number;
+    arg: number;
+    sab?: Int32Array;
+}
+
+export declare interface StartResult {
+    exitCode: number;
+    instance: WebAssembly.Instance;
+}
+
+export declare interface TerminateAllThreadsPayload {
+}
+
+export declare interface ThreadErrorPayload {
+    error: SerializedError;
+    phase: ThreadFailurePhase;
+    tid?: number;
+}
+
+export declare type ThreadFailurePhase = 'load' | 'start' | 'async-work' | 'message' | 'messageerror' | 'exit';
+
+export declare class ThreadManager {
+    unusedWorkers: WorkerLike[];
+    pthreads: Record<number, WorkerLike>;
+    get nextWorkerID(): number;
+    wasmModule: WebAssembly.Module | null;
+    wasmMemory: WebAssembly.Memory | null;
+    private readonly messageEvents;
+    private readonly registeredWorkers;
+    private readonly expectedTerminations;
+    private readonly loadRejects;
+    private _fatalError;
+    private readonly _childThread;
+    private readonly _onCreateWorker;
+    private readonly _reuseWorker;
+    private readonly _beforeLoad?;
+    readonly printErr: (message: string) => void;
+    threadSpawn?: ((startArg: number, errorOrTid?: number) => number);
+    constructor(options: ThreadManagerOptions);
+    init(): void;
+    initMainThread(): void;
+    private preparePool;
+    shouldPreloadWorkers(): boolean;
+    loadWasmModuleToAllWorkers(): Promise<WorkerLike[]>;
+    preloadWorkers(): Promise<WorkerLike[]>;
+    setup(wasmModule: WebAssembly.Module, wasmMemory: WebAssembly.Memory): void;
+    private assertRunning;
+    private fail;
+    markId(worker: WorkerLike): number;
+    returnWorkerToPool(worker: WorkerLike): void;
+    loadWasmModuleToWorker(worker: WorkerLike, sab?: Int32Array): Promise<WorkerLike>;
+    allocateUnusedWorker(): WorkerLike;
+    getNewWorker(sab?: Int32Array): WorkerLike | undefined;
+    cleanThread(worker: WorkerLike, tid: number, force?: boolean): void;
+    terminateWorker(worker: WorkerLike): void;
+    terminateAllThreads(): void;
+    private shutdownAllWorkers;
+    addMessageEventListener(worker: WorkerLike, onMessage: (e: WorkerMessageEvent) => void): () => void;
+    fireMessageEvent(worker: WorkerLike, e: WorkerMessageEvent): void;
+}
+
+export declare type ThreadManagerOptions = ThreadManagerOptionsMain | ThreadManagerOptionsChild;
+
+export declare interface ThreadManagerOptionsBase {
+    printErr?: (message: string) => void;
+    threadSpawn?: (startArg: number, errorOrTid?: number) => number;
+}
+
+export declare interface ThreadManagerOptionsChild extends ThreadManagerOptionsBase {
+    childThread: true;
+}
+
+export declare interface ThreadManagerOptionsMain extends ThreadManagerOptionsBase {
+    beforeLoad?: (worker: WorkerLike) => any;
+    reuseWorker?: boolean | number | ReuseWorkerOptions;
+    onCreateWorker: WorkerFactory;
+    childThread?: false;
+}
+
+export declare class ThreadMessageHandler {
+    protected instance: WebAssembly.Instance | undefined;
+    private messagesBeforeLoad;
+    protected postMessage: (message: any) => void;
+    protected onLoad?: (data: LoadPayload) => WebAssembly.WebAssemblyInstantiatedSource | PromiseLike<WebAssembly.WebAssemblyInstantiatedSource>;
+    protected onError: (error: Error, type: WorkerMessageType) => void;
+    constructor(options?: ThreadMessageHandlerOptions);
+    instantiate(data: LoadPayload): WebAssembly.WebAssemblyInstantiatedSource | PromiseLike<WebAssembly.WebAssemblyInstantiatedSource>;
+    handle(e: WorkerMessageEvent<MessageEventData<WorkerMessageType>>): void;
+    private _load;
+    private _start;
+    protected _loaded(err: Error | null, source: WebAssembly.WebAssemblyInstantiatedSource | null, payload: LoadPayload): void;
+    protected handleAfterLoad<E extends WorkerMessageEvent>(e: E, f: (e: E) => void): void;
+    protected beforeReportError(_error: Error, _type: WorkerMessageType | 'async-worker-init', _tid?: number): void;
+    protected reportError(value: unknown, type: WorkerMessageType | 'async-worker-init', tid?: number): void;
+}
+
+export declare interface ThreadMessageHandlerOptions {
+    onLoad?: (data: LoadPayload) => WebAssembly.WebAssemblyInstantiatedSource | PromiseLike<WebAssembly.WebAssemblyInstantiatedSource>;
+    onError?: (error: Error, type: WorkerMessageType) => void;
+    postMessage?: (message: any) => void;
+}
+
+export declare interface WASIInstance {
+    readonly wasiImport?: Record<string, any>;
+    initialize(instance: object): void;
+    start(instance: object): number;
+    getImportObject?(): any;
+}
+
+export declare class WASIThreads {
+    PThread: ThreadManager | undefined;
+    private wasmMemory;
+    private wasmInstance;
+    private readonly threadSpawn;
+    readonly childThread: boolean;
+    private readonly postMessage;
+    readonly wasi: WASIInstance;
+    constructor(options: WASIThreadsOptions);
+    getImportObject(): {
+        wasi: WASIThreadsImports;
+    };
+    setup(wasmInstance: WebAssembly.Instance, wasmModule: WebAssembly.Module, wasmMemory?: WebAssembly.Memory): void;
+    preloadWorkers(): Promise<WorkerLike[]>;
+    initialize(instance: WebAssembly.Instance, module: WebAssembly.Module, memory?: WebAssembly.Memory): WebAssembly.Instance;
+    start(instance: WebAssembly.Instance, module: WebAssembly.Module, memory?: WebAssembly.Memory): StartResult;
+    terminateAllThreads(): void;
+}
+
+export declare interface WASIThreadsImports {
+    'thread-spawn': (startArg: number, errorOrTid?: number) => number;
+}
+
+export declare type WASIThreadsOptions = MainThreadOptions | ChildThreadOptions;
+
+export declare type WorkerFactory = (ctx: {
+    type: string;
+    name: string;
+}) => WorkerLike;
+
+export declare type WorkerLike = (Worker | Worker_2) & {
+    whenLoaded?: Promise<WorkerLike>;
+    loaded?: boolean;
+    __emnapi_tid?: number;
+};
+
+export declare interface WorkerMessageEvent<T = any> {
+    data: T;
+}
+
+export declare type WorkerMessageType = 'load' | 'start';
+
+export { }