veryfront 0.1.545 → 0.1.546

package/src/src/tool/remote-source-tools.ts

@@ -1,62 +0,0 @@
-import { defineSchema } from "../schemas/index.js";
-import { dynamicTool } from "./factory.js";
-import type { RemoteToolSource, Tool, ToolDefinition, ToolExecutionContext } from "./types.js";
-
-export interface RemoteToolMaterializationOptions {
-  context?: ToolExecutionContext;
-  toolNameAliases?: Record<string, string>;
-}
-
-/**
- * Permissive input schema used for remote tools whose JSON Schema is
- * sourced from the remote and we only need a no-op contract `Schema<T>` to
- * satisfy the runtime input-validation pass. Equivalent to
- * `z.object({}).passthrough()`.
- */
-const getRemoteToolPassthroughSchema = defineSchema((v) => v.object({}).passthrough());
-
-function toToolInputRecord(input: unknown): Record<string, unknown> {
-  if (typeof input !== "object" || input === null || Array.isArray(input)) {
-    return {};
-  }
-
-  return Object.fromEntries(Object.entries(input));
-}
-
-export function createToolsFromRemoteDefinitions(
-  source: RemoteToolSource,
-  definitions: readonly ToolDefinition[],
-  options: Omit<RemoteToolMaterializationOptions, "context"> = {},
-): Record<string, Tool<unknown, unknown>> {
-  return Object.fromEntries(
-    definitions.map((definition) => {
-      const toolName = options.toolNameAliases?.[definition.name] ?? definition.name;
-
-      return [
-        toolName,
-        dynamicTool({
-          id: toolName,
-          description: definition.description,
-          inputSchema: getRemoteToolPassthroughSchema(),
-          inputSchemaJson: definition.parameters,
-          mcp: {
-            title: definition.title,
-            annotations: definition.annotations,
-          },
-          execute: async (input, context) =>
-            await source.executeTool(definition.name, toToolInputRecord(input), context),
-        }),
-      ];
-    }),
-  );
-}
-
-export async function loadRemoteToolsFromSource(
-  source: RemoteToolSource,
-  options: RemoteToolMaterializationOptions = {},
-): Promise<Record<string, Tool<unknown, unknown>>> {
-  const definitions = await source.listTools(options.context);
-  return createToolsFromRemoteDefinitions(source, definitions, {
-    toolNameAliases: options.toolNameAliases,
-  });
-}

package/src/src/tool/result.ts

@@ -1,23 +0,0 @@
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null;
-}
-
-export function hasToolExecutionErrorMarker(value: unknown): boolean {
-  if (!isRecord(value)) {
-    return false;
-  }
-
-  return typeof value.error === "string" || value.isError === true;
-}
-
-export function isErroredToolExecutionResult(result: unknown): boolean {
-  if (hasToolExecutionErrorMarker(result)) {
-    return true;
-  }
-
-  if (!isRecord(result)) {
-    return false;
-  }
-
-  return hasToolExecutionErrorMarker(result.output);
-}

package/src/src/tool/schema/index.ts

@@ -1,8 +0,0 @@
-/**
- * Tool Schema
- *
- * @module tool/schema
- */
-
-export type { JsonSchema } from "./json-schema.js";
-export { isOptionalSchema, zodToJsonSchema } from "./zod-json-schema.js";

package/src/src/tool/schema/json-schema.ts

@@ -1,9 +0,0 @@
-/**
- * Back-compat re-export. The canonical `JsonSchema` type now lives in
- * `src/extensions/schema/json-schema.ts` so the `SchemaValidator`
- * contract can reference it without an upward import.
- *
- * @module tool/schema/json-schema
- */
-
-export type { JsonSchema } from "../../extensions/schema/json-schema.js";

package/src/src/tool/schema/zod-json-schema.ts

@@ -1,87 +0,0 @@
-/**
- * Schema → JSON Schema conversion shim.
- *
- * Historically this module was the in-tree zod-to-JSON-Schema converter.
- * After Phase B2 the conversion lives behind the `SchemaValidator`
- * contract (`toJsonSchema` / `isOptional`) and the zod-aware logic moved
- * to `extensions/ext-schema-zod/src/json-schema.ts`. This file is kept as a
- * back-compat surface so existing callers (`tool/registry.ts`,
- * `tool/factory.ts`, `workflow/registry.ts`, `routing/api/openapi/...`,
- * `mcp/server.ts`, `cli/mcp/server.ts`) continue to compile.
- *
- * Inputs may be either an opaque `Schema<T>` produced by `defineSchema`
- * (the modern path) or a raw zod schema (legacy path during the migration
- * window). Both shapes are routed through the `SchemaValidator` contract
- * so no zod-specific logic remains in this file.
- *
- * @module tool/schema/zod-json-schema
- */
-
-import type { JsonSchema, Schema } from "../../extensions/schema/index.js";
-import {
-  isOptionalSchema as schemaIsOptional,
-  schemaToJsonSchema,
-} from "../../schemas/json-schema.js";
-
-/** Detect contract `Schema<T>` (carries a `__zod` brand from the ext-schema-zod adapter). */
-function isContractSchema(value: unknown): value is Schema<unknown> {
-  if (value === null || typeof value !== "object") return false;
-  if ("__zod" in value) return true;
-  // Fallback: defineSchema-produced wrappers expose `_output`, `parse`, and
-  // `safeParse`. Some test doubles may construct these directly.
-  return (
-    "_output" in value &&
-    typeof (value as { parse?: unknown }).parse === "function" &&
-    typeof (value as { safeParse?: unknown }).safeParse === "function"
-  );
-}
-
-/** Detect a raw zod schema: object with `_def` carrying `typeName` (v3) or `type` (v4). */
-function isRawZodSchema(value: unknown): value is { _def: { typeName?: string; type?: string } } {
-  if (value === null || typeof value !== "object") return false;
-  if (!("_def" in value)) return false;
-  const def = (value as { _def: unknown })._def as { typeName?: unknown; type?: unknown } | null;
-  if (!def || typeof def !== "object") return false;
-  return typeof def.typeName === "string" || typeof def.type === "string";
-}
-
-/**
- * Adapter that wraps a raw zod schema in the contract's `Schema<unknown>`
- * shape so the contract's `toJsonSchema` / `isOptional` can unwrap it via
- * the `__zod` brand.
- */
-function wrapRawZod(value: unknown): Schema<unknown> {
-  return { __zod: value } as unknown as Schema<unknown>;
-}
-
-/**
- * Convert a `Schema<T>` (or, transitionally, a raw zod schema) into a
- * JSON Schema document.
- *
- * Throws if the input is neither a contract schema nor a raw zod schema —
- * matches the pre-B2 behavior of the original `zodToJsonSchema` guard.
- */
-export function zodToJsonSchema(schema: unknown): JsonSchema {
-  if (isContractSchema(schema)) {
-    return schemaToJsonSchema(schema);
-  }
-  if (isRawZodSchema(schema)) {
-    return schemaToJsonSchema(wrapRawZod(schema));
-  }
-  throw new Error("Invalid Zod schema: missing _def property");
-}
-
-/**
- * Returns `true` when the schema permits `undefined`. Accepts both
- * contract `Schema<T>` and raw zod schemas for the same compatibility
- * reasons as `zodToJsonSchema` above.
- */
-export function isOptionalSchema(schema: unknown): boolean {
-  if (isContractSchema(schema)) {
-    return schemaIsOptional(schema);
-  }
-  if (isRawZodSchema(schema)) {
-    return schemaIsOptional(wrapRawZod(schema));
-  }
-  return false;
-}

package/src/src/tool/sleep.ts

@@ -1,102 +0,0 @@
-import * as dntShim from "../../_dnt.shims.js";
-import type { InferSchema, Schema } from "../extensions/schema/index.js";
-import { resolveSchemaValidator } from "../schemas/define.js";
-import { tool } from "./factory.js";
-import type { Tool } from "./types.js";
-
-export const DEFAULT_SLEEP_TOOL_MAX_SECONDS = 60;
-
-export type SleepToolWait = (milliseconds: number) => Promise<void> | void;
-
-export type CreateSleepToolOptions = {
-  maxSeconds?: number;
-  wait?: SleepToolWait;
-};
-
-const defaultSleepToolWait: SleepToolWait = (milliseconds) =>
-  new Promise((resolve) => {
-    dntShim.setTimeout(resolve, milliseconds);
-  });
-
-interface SleepToolInputShape {
-  seconds: number;
-}
-
-/**
- * Build the sleep-tool input schema parameterised by `maxSeconds`.
- *
- * Resolves the `SchemaValidator` through the shared fallback path (rather than going
- * through `defineSchema`) because `defineSchema` produces a memoized
- * zero-arg getter — incompatible with per-instance parametric schemas.
- */
-function createSleepToolInputSchema(maxSeconds: number): Schema<SleepToolInputShape> {
-  const v = resolveSchemaValidator();
-  return v.object({
-    seconds: v.number().min(1).max(maxSeconds).describe(
-      `Number of seconds to wait (1-${maxSeconds})`,
-    ),
-  }) as unknown as Schema<SleepToolInputShape>;
-}
-
-export type SleepToolInput = InferSchema<ReturnType<typeof createSleepToolInputSchema>>;
-
-export type SleepToolOutput = {
-  sleptFor: number;
-  message: string;
-};
-
-export function createSleepTool(options: CreateSleepToolOptions = {}) {
-  const maxSeconds = options.maxSeconds ?? DEFAULT_SLEEP_TOOL_MAX_SECONDS;
-  const wait = options.wait ?? defaultSleepToolWait;
-
-  return tool<SleepToolInput, SleepToolOutput>({
-    id: "sleep",
-    description:
-      `Wait for a specified number of seconds before continuing. Use this when a task needs to pause execution, such as waiting for an external process to complete or adding a delay between operations. Maximum sleep time is ${maxSeconds} seconds.`,
-    inputSchema: createSleepToolInputSchema(maxSeconds),
-    execute: async ({ seconds }) => {
-      const clampedSeconds = Math.min(Math.max(1, seconds), maxSeconds);
-      await wait(clampedSeconds * 1000);
-      return {
-        sleptFor: clampedSeconds,
-        message: `Waited for ${clampedSeconds} second${clampedSeconds === 1 ? "" : "s"}`,
-      };
-    },
-  });
-}
-
-/**
- * Lazily-built default sleep tool.
- *
- * Construction is deferred to first access so importers don't pay the
- * SchemaValidator-resolution cost (and don't fail under tests that haven't
- * registered the adapter) just by loading this module.
- */
-let cachedDefaultSleepTool: Tool<SleepToolInput, SleepToolOutput> | undefined;
-function getDefaultSleepTool(): Tool<SleepToolInput, SleepToolOutput> {
-  cachedDefaultSleepTool ??= createSleepTool();
-  return cachedDefaultSleepTool;
-}
-
-/**
- * Default sleep tool (max 60 s) exposed as a property accessor so the
- * underlying `tool({...})` materialization is deferred until first use.
- * Preserves the existing `sleepTool.execute(...)` call shape.
- */
-export const sleepTool: Tool<SleepToolInput, SleepToolOutput> = new Proxy(
-  {} as Tool<SleepToolInput, SleepToolOutput>,
-  {
-    get(_target, prop, receiver) {
-      return Reflect.get(getDefaultSleepTool(), prop, receiver);
-    },
-    has(_target, prop) {
-      return prop in getDefaultSleepTool();
-    },
-    ownKeys() {
-      return Reflect.ownKeys(getDefaultSleepTool());
-    },
-    getOwnPropertyDescriptor(_target, prop) {
-      return Object.getOwnPropertyDescriptor(getDefaultSleepTool(), prop);
-    },
-  },
-);

package/src/src/tool/tracing.ts

@@ -1,70 +0,0 @@
-import type { HostToolSet } from "./host-tools.js";
-import type { ToolExecutionContext } from "./types.js";
-
-export type HostToolTraceRunner = <TResult>(
-  spanName: string,
-  operation: () => TResult,
-) => TResult;
-
-export type HostToolTraceAttributes = Record<string, unknown>;
-
-export type HostToolTraceAttributeInput = {
-  toolName: string;
-  toolCallId: string | undefined;
-  context: ToolExecutionContext | undefined;
-};
-
-export type TraceHostToolsOptions<
-  TAttributes extends HostToolTraceAttributes = HostToolTraceAttributes,
-> = {
-  trace: HostToolTraceRunner;
-  buildAttributes?: (
-    input: HostToolTraceAttributeInput,
-  ) => TAttributes | undefined;
-  setAttributes?: (attributes: TAttributes) => void;
-  getSpanName?: (toolName: string) => string;
-};
-
-function defaultSpanName(toolName: string): string {
-  return `tool.${toolName}`;
-}
-
-function getToolCallId(context: ToolExecutionContext | undefined): string | undefined {
-  return typeof context?.toolCallId === "string" ? context.toolCallId : undefined;
-}
-
-export function traceHostTools<
-  TAttributes extends HostToolTraceAttributes = HostToolTraceAttributes,
->(
-  tools: HostToolSet,
-  options: TraceHostToolsOptions<TAttributes>,
-): HostToolSet {
-  const traced: HostToolSet = {};
-  const getSpanName = options.getSpanName ?? defaultSpanName;
-
-  for (const [toolName, definition] of Object.entries(tools)) {
-    if (!definition.execute) {
-      traced[toolName] = definition;
-      continue;
-    }
-
-    const originalExecute = definition.execute;
-    traced[toolName] = {
-      ...definition,
-      execute: (input: unknown, context: ToolExecutionContext | undefined) =>
-        options.trace(getSpanName(toolName), () => {
-          const attributes = options.buildAttributes?.({
-            toolName,
-            toolCallId: getToolCallId(context),
-            context,
-          });
-          if (attributes) {
-            options.setAttributes?.(attributes);
-          }
-          return originalExecute(input, context);
-        }),
-    };
-  }
-
-  return traced;
-}

package/src/src/tool/types.ts

@@ -1,173 +0,0 @@
-/****
- * Tool type definitions
- */
-
-import type { JsonSchema, Schema } from "../extensions/schema/index.js";
-import type { BlobStorage } from "../workflow/blob/types.js";
-import type { ToolAnnotations } from "../mcp/annotations.js";
-
-/**
- * Tool configuration options
- */
-// deno-lint-ignore no-explicit-any -- generic erasure: interface must accept any concrete ToolConfig instantiation
-export interface ToolConfig<TInput = any, TOutput = any> {
-  /** Tool identifier (optional, inferred from filename) */
-  id?: string;
-
-  /** Tool description for the AI model */
-  description: string;
-
-  /**
-   * Input schema produced via `defineSchema((v) => …)` (or any
-   * `SchemaValidator`-backed builder). Validates input before `execute` runs
-   * and seeds the JSON Schema exposed to AI providers.
-   */
-  inputSchema: Schema<TInput>;
-
-  /**
-   * Allow unknown/non-contract schemas to fall back to a permissive JSON
-   * schema. Use only for truly dynamic tools; prefer `v.unknown()` or
-   * `v.any()` from the SchemaValidator DSL instead.
-   */
-  allowUnknownSchema?: boolean;
-
-  /**
-   * Tool execution function
-   */
-  execute: (input: TInput, context?: ToolExecutionContext) => Promise<TOutput> | TOutput;
-
-  /** MCP configuration */
-  mcp?: {
-    /** Expose via MCP */
-    enabled?: boolean;
-
-    /** Require authentication */
-    requiresAuth?: boolean;
-
-    /** Cache policy */
-    cachePolicy?: "no-cache" | "cache" | "cache-first";
-
-    /** Human-readable title for display */
-    title?: string;
-    /** Behavioral hints for clients (MCP 2025-11-25) */
-    annotations?: ToolAnnotations;
-  };
-}
-
-/**
- * Context passed to tool execution
- */
-export interface ToolExecutionContext {
-  /** ID of the agent calling the tool (if any) */
-  agentId?: string;
-  /** Stable ID for the current tool call when the runtime is tracking tool lifecycles */
-  toolCallId?: string;
-  /** Project identity used by integration token resolution */
-  projectId?: string;
-  /** End-user identity for per-user token resolution in integration tools */
-  endUserId?: string;
-  /** Abort signal for cooperative cancellation during long-running tool execution */
-  abortSignal?: AbortSignal;
-  /** Progress token for sending progress notifications (MCP 2025-11-25) */
-  progressToken?: string | number;
-  /**
-   * Optional host-provided callback for publishing generic runtime data events.
-   *
-   * The payload intentionally stays framework-generic so hosts can surface
-   * structured runtime signals without leaking product-specific event shapes
-   * into the open-core contract.
-   */
-  publishDataEvent?: (event: ToolExecutionDataEvent) => void | Promise<void>;
-  /** Additional context */
-  [key: string]: unknown;
-  /** Blob storage access (if configured in workflow) */
-  blobStorage?: BlobStorage;
-}
-
-export interface ToolExecutionDataEvent {
-  /** Host-defined event type */
-  type: string;
-  /** Optional structured event payload */
-  data?: unknown;
-  /** Additional host-defined fields */
-  [key: string]: unknown;
-}
-
-/**
- * Tool type discriminator
- * - 'function': Standard tool with known input/output types (default)
- * - 'dynamic': Dynamic tool with unknown types (MCP tools, user-defined functions)
- */
-type ToolType = "function" | "dynamic";
-
-/**
- * Tool instance (returned by tool() function)
- */
-// deno-lint-ignore no-explicit-any -- generic erasure: interface must accept any concrete Tool instantiation
-export interface Tool<TInput = any, TOutput = any> {
-  /** Tool ID */
-  id: string;
-  /** Internal marker used to distinguish autogenerated placeholder ids from explicit ids. */
-  __veryfrontGeneratedId?: string;
-
-  /**
-   * Tool type discriminator
-   * - 'function': Standard tool with known types (default)
-   * - 'dynamic': Dynamic tool for MCP, user-defined functions, etc.
-   */
-  type: ToolType;
-
-  /** Tool description */
-  description: string;
-
-  /** Input schema produced by `defineSchema` (or any SchemaValidator-backed builder). */
-  inputSchema: Schema<TInput>;
-
-  /**
-   * Pre-converted JSON Schema (for OpenAI/provider compatibility)
-   * This is generated at tool creation time to avoid bundling issues
-   */
-  inputSchemaJson?: JsonSchema;
-
-  /**
-   * Execute the tool
-   */
-  execute: (input: TInput, context?: ToolExecutionContext) => Promise<TOutput>;
-
-  /** MCP configuration */
-  mcp?: ToolConfig["mcp"];
-}
-
-/**
- * Runtime tool map keyed by the tool name exposed to an agent.
- *
- * Hosts can use this for already-materialized framework tools, including
- * tools loaded from remote sources.
- */
-export type ToolSet = Record<string, Tool<unknown, unknown>>;
-
-/**
- * Provider-facing tool definition used for model/tool registration.
- */
-export interface ToolDefinition {
-  name: string;
-  description: string;
-  parameters: JsonSchema;
-  title?: string;
-  annotations?: ToolAnnotations;
-}
-
-/**
- * Remote tool source loaded dynamically at runtime.
- * Hosts can provide these to expose tools from remote MCP-compatible systems
- * without registering those tools globally inside the framework.
- */
-export interface RemoteToolSource {
-  id: string;
-  listTools(context?: ToolExecutionContext): Promise<ToolDefinition[]>;
-  executeTool(
-    toolName: string,
-    args: Record<string, unknown>,
-    context?: ToolExecutionContext,
-  ): Promise<unknown>;
-}

package/src/src/transforms/css-modules/naming.ts

@@ -1,152 +0,0 @@
-/**
- * CSS Module naming and selector rewriting helpers.
- *
- * Provides deterministic class-name scoping that is stable across
- * transform/runtime boundaries and HTML CSS aggregation.
- */
-
-const CSS_MODULE_EXTENSION = ".module.css";
-
-/**
- * Normalize a module key to a stable slash-based format.
- * Removes query/hash suffixes and normalizes duplicate separators.
- */
-export function normalizeCssModuleKey(path: string): string {
-  const withoutFilePrefix = path.startsWith("file://") ? path.slice("file://".length) : path;
-  const withoutQuery = withoutFilePrefix.replace(/[?#].*$/, "");
-  const slashed = withoutQuery.replace(/\\/g, "/");
-  const collapsed = slashed.replace(/\/{2,}/g, "/");
-  if (collapsed.startsWith("/")) return collapsed;
-  if (collapsed.startsWith("http://") || collapsed.startsWith("https://")) return collapsed;
-  return `/${collapsed.replace(/^\/+/, "")}`;
-}
-
-function dirname(path: string): string {
-  const normalized = normalizeCssModuleKey(path);
-  const lastSlash = normalized.lastIndexOf("/");
-  return lastSlash <= 0 ? "/" : normalized.slice(0, lastSlash);
-}
-
-function normalizePathSegments(path: string): string {
-  const normalized = normalizeCssModuleKey(path);
-  if (normalized.startsWith("http://") || normalized.startsWith("https://")) return normalized;
-
-  const parts = normalized.split("/").filter(Boolean);
-  const resolved: string[] = [];
-
-  for (const part of parts) {
-    if (part === ".") continue;
-    if (part === "..") {
-      resolved.pop();
-      continue;
-    }
-    resolved.push(part);
-  }
-
-  return `/${resolved.join("/")}`;
-}
-
-/**
- * Resolve a CSS import specifier to a deterministic module key.
- * Supports relative imports, @/ aliases, absolute paths, and URLs.
- */
-export function resolveCssModuleKey(
-  specifier: string,
-  importerFilePath: string,
-  projectDir: string,
-): string {
-  if (specifier.startsWith("http://") || specifier.startsWith("https://")) {
-    return normalizeCssModuleKey(specifier);
-  }
-
-  if (specifier.startsWith("@/")) {
-    const aliasPath = specifier.slice(2).replace(/^\/+/, "");
-    return normalizePathSegments(`${normalizeCssModuleKey(projectDir)}/${aliasPath}`);
-  }
-
-  if (specifier.startsWith("/")) {
-    return normalizePathSegments(specifier);
-  }
-
-  if (specifier.startsWith("./") || specifier.startsWith("../")) {
-    const importerDir = dirname(importerFilePath);
-    return normalizePathSegments(`${importerDir}/${specifier}`);
-  }
-
-  // Bare specifiers are uncommon for CSS in this system, but keep deterministic behavior.
-  return normalizeCssModuleKey(specifier);
-}
-
-function hashString(input: string): string {
-  let hash = 5381;
-  for (let i = 0; i < input.length; i++) {
-    hash = ((hash << 5) + hash) ^ input.charCodeAt(i);
-  }
-  return (hash >>> 0).toString(36);
-}
-
-function sanitizeToken(token: string): string {
-  return token.replace(/[^\w-]/g, "_");
-}
-
-/**
- * Build deterministic module scope info.
- */
-export function getCssModuleScope(moduleKey: string): { base: string; hash: string } {
-  const normalized = normalizeCssModuleKey(moduleKey);
-  const filename = normalized.split("/").pop() || "module";
-  const base = sanitizeToken(
-    filename.endsWith(CSS_MODULE_EXTENSION)
-      ? filename.slice(0, -CSS_MODULE_EXTENSION.length)
-      : filename.replace(/\.css$/, ""),
-  ) || "module";
-  const hash = hashString(normalized).slice(0, 6);
-  return { base, hash };
-}
-
-/**
- * Convert a local class name to its scoped CSS Module class.
- */
-export function toScopedCssModuleClass(moduleKey: string, localName: string): string {
-  const { base, hash } = getCssModuleScope(moduleKey);
-  const normalizedLocal = sanitizeToken(localName);
-  return `${base}_${normalizedLocal}__${hash}`;
-}
-
-function maskGlobalSelectors(css: string): { masked: string; restore: (input: string) => string } {
-  const segments: string[] = [];
-  const masked = css.replace(/:global\(([^()]*)\)/g, (match) => {
-    const token = `__VF_CSS_GLOBAL_${segments.length}__`;
-    segments.push(match);
-    return token;
-  });
-
-  return {
-    masked,
-    restore: (input: string) => {
-      let result = input;
-      for (const [i, segment] of segments.entries()) {
-        result = result.replaceAll(`__VF_CSS_GLOBAL_${i}__`, segment);
-      }
-      return result;
-    },
-  };
-}
-
-/**
- * Rewrite `.module.css` selectors to deterministic scoped class names.
- * Keeps `:global(...)` segments untouched.
- */
-export function rewriteCssModuleContent(content: string, moduleKey: string): string {
-  const { masked, restore } = maskGlobalSelectors(content);
-  // After :global() masking, every `.identifier` in the CSS is a local class
-  // selector. No lookbehind needed — numeric decimals like `0.5em` won't
-  // match because digits aren't in [_a-zA-Z].
-  const rewritten = masked.replace(
-    /\.([_a-zA-Z][_a-zA-Z0-9-]*)/g,
-    (_match, className: string) => {
-      return `.${toScopedCssModuleClass(moduleKey, className)}`;
-    },
-  );
-  return restore(rewritten);
-}