@ttsc/unplugin 0.30.2 → 0.30.4

package/lib/core/viteServe.d.cts

@@ -1,4 +1,4 @@
-import type { ITtscCompilerTransformation } from "ttsc";
+import { type TtscWatchInput } from "./transform.cjs";
 /** One module node inside a Vite module graph; opaque to this module. */
 type ViteModuleNodeLike = object;
 /**
@@ -30,49 +30,46 @@ interface ViteEnvironmentLike {
  * carries.
  */
 export interface ViteDevServerLike {
+    config?: {
+        root?: string;
+    };
     environments?: Record<string, ViteEnvironmentLike>;
     hot?: ViteHotChannelLike;
     moduleGraph?: ViteModuleGraphLike;
     ws?: ViteHotChannelLike;
 }
+export interface ViteServeWatchOperations {
+    /** Override case-policy discovery for a simulated host filesystem. */
+    caseSensitive?(directory: string): boolean;
+    /** Override path semantics when testing a non-host platform. */
+    platform?: NodeJS.Platform;
+    poll(listener: () => void): {
+        close(): void;
+    };
+    watch(root: string, listener: (eventType: string, file: string | null) => void, onError: () => void): {
+        close(): void;
+    };
+}
+/** Serve-time compiler dependencies never enter Vite's runtime import graph. */
+export interface ViteServeInputWatch {
+    attach(server: ViteDevServerLike): void;
+    begin(): number;
+    dispose(): Promise<void>;
+    /** Release every compiler input owned by one removed source module. */
+    forget(importer: string): void;
+    replace(importer: string, inputs: readonly TtscWatchInput[], failed?: boolean, startedAt?: number): void;
+}
 /**
- * Filesystem watch for derived watch inputs that Vite cannot safely register as
- * added imports while a development server is running.
+ * A bounded recursive filesystem observer shared by all served modules.
  *
- * Vite serve treats every transform-context `addWatchFile()` registration as an
- * added import: `TransformPluginContext.addWatchFile` stores the path in
- * `_addedImports`, and `vite:import-analysis` resolves each entry like a real
- * import of the transformed module. A missing path or an existing directory
- * that failed a compiler file predicate then fails that resolve and turns the
- * importer's first request into a 500, even though the transform succeeded.
- *
- * This registry is the serve-only replacement for those registrations. Each
- * path is polled until its exact compiler predicate observation changes; legacy
- * envelopes retain their exists-or-file availability check. Its importers are
- * then invalidated in the server's module graphs and one full-reload is sent,
- * so the next request retransforms against the new resolution winner. The
- * project transform cache re-validates the compiler observation, so the
- * retransform recompiles instead of replaying.
+ * Vite resolves transform-context addWatchFile as a runtime import, including
+ * type-only .server files and non-module plugin assets. Use a separate watcher
+ * for compiler inputs, including node_modules, which Vite's watcher ignores.
+ * Ordinary files use events after their initial subscription is observed.
+ * Missing spellings and directory predicates use the recursive observer for
+ * their nearest available scope. Inputs a native scope cannot safely cover
+ * share one bounded fallback poll; linked files also share topology checks
+ * because retargeting a junction need not emit events on its old descendants.
  */
-export interface ViteServeMissingInputWatch {
-    /** Adopt the dev server whose module graphs creation events invalidate. */
-    attach(server: ViteDevServerLike): void;
-    /** Stop every poll; safe to call repeatedly. */
-    dispose(): void;
-    /**
-     * Report whether a dev server has ever been attached. This is not a liveness
-     * predicate — the reference intentionally survives the server's close (see
-     * {@link dispose}) — so route decisions must also gate on the resolved
-     * config's `command`, as the adapter does.
-     */
-    serving(): boolean;
-    /** Register one unsafe watch input and its exact recorded condition. */
-    watch(input: string, importer: string, condition: ViteServeInputWatchCondition): void;
-}
-/** A legacy availability condition or an exact compiler predicate proof. */
-export type ViteServeInputWatchCondition = "exists" | "file" | ITtscCompilerTransformation.IInputObservation;
-/** Create an empty missing-input watch for one plugin instance. */
-export declare function createViteServeMissingInputWatch(): ViteServeMissingInputWatch;
-/** Key a private poll by predicate and exact lexical spelling. */
-export declare function viteServeMissingInputWatchKey(input: string, condition: ViteServeInputWatchCondition): string;
+export declare function createViteServeInputWatch(operations?: Partial<ViteServeWatchOperations>): ViteServeInputWatch;
 export {};

package/lib/core/viteServe.d.mts

@@ -1,4 +1,4 @@
-import type { ITtscCompilerTransformation } from "ttsc";
+import { type TtscWatchInput } from "./transform.mjs";
 /** One module node inside a Vite module graph; opaque to this module. */
 type ViteModuleNodeLike = object;
 /**
@@ -30,49 +30,46 @@ interface ViteEnvironmentLike {
  * carries.
  */
 export interface ViteDevServerLike {
+    config?: {
+        root?: string;
+    };
     environments?: Record<string, ViteEnvironmentLike>;
     hot?: ViteHotChannelLike;
     moduleGraph?: ViteModuleGraphLike;
     ws?: ViteHotChannelLike;
 }
+export interface ViteServeWatchOperations {
+    /** Override case-policy discovery for a simulated host filesystem. */
+    caseSensitive?(directory: string): boolean;
+    /** Override path semantics when testing a non-host platform. */
+    platform?: NodeJS.Platform;
+    poll(listener: () => void): {
+        close(): void;
+    };
+    watch(root: string, listener: (eventType: string, file: string | null) => void, onError: () => void): {
+        close(): void;
+    };
+}
+/** Serve-time compiler dependencies never enter Vite's runtime import graph. */
+export interface ViteServeInputWatch {
+    attach(server: ViteDevServerLike): void;
+    begin(): number;
+    dispose(): Promise<void>;
+    /** Release every compiler input owned by one removed source module. */
+    forget(importer: string): void;
+    replace(importer: string, inputs: readonly TtscWatchInput[], failed?: boolean, startedAt?: number): void;
+}
 /**
- * Filesystem watch for derived watch inputs that Vite cannot safely register as
- * added imports while a development server is running.
+ * A bounded recursive filesystem observer shared by all served modules.
  *
- * Vite serve treats every transform-context `addWatchFile()` registration as an
- * added import: `TransformPluginContext.addWatchFile` stores the path in
- * `_addedImports`, and `vite:import-analysis` resolves each entry like a real
- * import of the transformed module. A missing path or an existing directory
- * that failed a compiler file predicate then fails that resolve and turns the
- * importer's first request into a 500, even though the transform succeeded.
- *
- * This registry is the serve-only replacement for those registrations. Each
- * path is polled until its exact compiler predicate observation changes; legacy
- * envelopes retain their exists-or-file availability check. Its importers are
- * then invalidated in the server's module graphs and one full-reload is sent,
- * so the next request retransforms against the new resolution winner. The
- * project transform cache re-validates the compiler observation, so the
- * retransform recompiles instead of replaying.
+ * Vite resolves transform-context addWatchFile as a runtime import, including
+ * type-only .server files and non-module plugin assets. Use a separate watcher
+ * for compiler inputs, including node_modules, which Vite's watcher ignores.
+ * Ordinary files use events after their initial subscription is observed.
+ * Missing spellings and directory predicates use the recursive observer for
+ * their nearest available scope. Inputs a native scope cannot safely cover
+ * share one bounded fallback poll; linked files also share topology checks
+ * because retargeting a junction need not emit events on its old descendants.
  */
-export interface ViteServeMissingInputWatch {
-    /** Adopt the dev server whose module graphs creation events invalidate. */
-    attach(server: ViteDevServerLike): void;
-    /** Stop every poll; safe to call repeatedly. */
-    dispose(): void;
-    /**
-     * Report whether a dev server has ever been attached. This is not a liveness
-     * predicate — the reference intentionally survives the server's close (see
-     * {@link dispose}) — so route decisions must also gate on the resolved
-     * config's `command`, as the adapter does.
-     */
-    serving(): boolean;
-    /** Register one unsafe watch input and its exact recorded condition. */
-    watch(input: string, importer: string, condition: ViteServeInputWatchCondition): void;
-}
-/** A legacy availability condition or an exact compiler predicate proof. */
-export type ViteServeInputWatchCondition = "exists" | "file" | ITtscCompilerTransformation.IInputObservation;
-/** Create an empty missing-input watch for one plugin instance. */
-export declare function createViteServeMissingInputWatch(): ViteServeMissingInputWatch;
-/** Key a private poll by predicate and exact lexical spelling. */
-export declare function viteServeMissingInputWatchKey(input: string, condition: ViteServeInputWatchCondition): string;
+export declare function createViteServeInputWatch(operations?: Partial<ViteServeWatchOperations>): ViteServeInputWatch;
 export {};

package/lib/core/viteServe.d.ts

@@ -1,4 +1,4 @@
-import type { ITtscCompilerTransformation } from "ttsc";
+import { type TtscWatchInput } from "./transform";
 /** One module node inside a Vite module graph; opaque to this module. */
 type ViteModuleNodeLike = object;
 /**
@@ -30,49 +30,46 @@ interface ViteEnvironmentLike {
  * carries.
  */
 export interface ViteDevServerLike {
+    config?: {
+        root?: string;
+    };
     environments?: Record<string, ViteEnvironmentLike>;
     hot?: ViteHotChannelLike;
     moduleGraph?: ViteModuleGraphLike;
     ws?: ViteHotChannelLike;
 }
+export interface ViteServeWatchOperations {
+    /** Override case-policy discovery for a simulated host filesystem. */
+    caseSensitive?(directory: string): boolean;
+    /** Override path semantics when testing a non-host platform. */
+    platform?: NodeJS.Platform;
+    poll(listener: () => void): {
+        close(): void;
+    };
+    watch(root: string, listener: (eventType: string, file: string | null) => void, onError: () => void): {
+        close(): void;
+    };
+}
+/** Serve-time compiler dependencies never enter Vite's runtime import graph. */
+export interface ViteServeInputWatch {
+    attach(server: ViteDevServerLike): void;
+    begin(): number;
+    dispose(): Promise<void>;
+    /** Release every compiler input owned by one removed source module. */
+    forget(importer: string): void;
+    replace(importer: string, inputs: readonly TtscWatchInput[], failed?: boolean, startedAt?: number): void;
+}
 /**
- * Filesystem watch for derived watch inputs that Vite cannot safely register as
- * added imports while a development server is running.
+ * A bounded recursive filesystem observer shared by all served modules.
  *
- * Vite serve treats every transform-context `addWatchFile()` registration as an
- * added import: `TransformPluginContext.addWatchFile` stores the path in
- * `_addedImports`, and `vite:import-analysis` resolves each entry like a real
- * import of the transformed module. A missing path or an existing directory
- * that failed a compiler file predicate then fails that resolve and turns the
- * importer's first request into a 500, even though the transform succeeded.
- *
- * This registry is the serve-only replacement for those registrations. Each
- * path is polled until its exact compiler predicate observation changes; legacy
- * envelopes retain their exists-or-file availability check. Its importers are
- * then invalidated in the server's module graphs and one full-reload is sent,
- * so the next request retransforms against the new resolution winner. The
- * project transform cache re-validates the compiler observation, so the
- * retransform recompiles instead of replaying.
+ * Vite resolves transform-context addWatchFile as a runtime import, including
+ * type-only .server files and non-module plugin assets. Use a separate watcher
+ * for compiler inputs, including node_modules, which Vite's watcher ignores.
+ * Ordinary files use events after their initial subscription is observed.
+ * Missing spellings and directory predicates use the recursive observer for
+ * their nearest available scope. Inputs a native scope cannot safely cover
+ * share one bounded fallback poll; linked files also share topology checks
+ * because retargeting a junction need not emit events on its old descendants.
  */
-export interface ViteServeMissingInputWatch {
-    /** Adopt the dev server whose module graphs creation events invalidate. */
-    attach(server: ViteDevServerLike): void;
-    /** Stop every poll; safe to call repeatedly. */
-    dispose(): void;
-    /**
-     * Report whether a dev server has ever been attached. This is not a liveness
-     * predicate — the reference intentionally survives the server's close (see
-     * {@link dispose}) — so route decisions must also gate on the resolved
-     * config's `command`, as the adapter does.
-     */
-    serving(): boolean;
-    /** Register one unsafe watch input and its exact recorded condition. */
-    watch(input: string, importer: string, condition: ViteServeInputWatchCondition): void;
-}
-/** A legacy availability condition or an exact compiler predicate proof. */
-export type ViteServeInputWatchCondition = "exists" | "file" | ITtscCompilerTransformation.IInputObservation;
-/** Create an empty missing-input watch for one plugin instance. */
-export declare function createViteServeMissingInputWatch(): ViteServeMissingInputWatch;
-/** Key a private poll by predicate and exact lexical spelling. */
-export declare function viteServeMissingInputWatchKey(input: string, condition: ViteServeInputWatchCondition): string;
+export declare function createViteServeInputWatch(operations?: Partial<ViteServeWatchOperations>): ViteServeInputWatch;
 export {};