@holo-js/adapter-shared 0.3.28 → 0.4.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Holo-JS contributors
+
+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/dist/.holo-build-fingerprint

@@ -0,0 +1 @@
+717ccaf9e57a434a91def4c1373ad81bf3ddf49e548dc31bfa883e0241e05136

package/dist/build.d.ts

@@ -6,7 +6,7 @@ type RealtimeDefinitionSourceMap = {
     readonly version: 3;
     readonly file: string;
     readonly sources: readonly string[];
-    readonly sourcesContent: readonly string[];
+    readonly sourcesContent?: readonly string[];
     readonly names: readonly string[];
     readonly mappings: string;
 };
@@ -17,8 +17,14 @@ type RealtimeDefinitionTransformResult = {
 type RealtimeDefinitionTransformOptions = {
     readonly preserveServerHandlers?: boolean;
 };
+type RealtimeDefinitionTransformInput = RealtimeDefinitionTransformOptions & {
+    readonly source: string;
+    readonly importTarget: string;
+    readonly filePath: string;
+};
 declare function stripRealtimeServerHandlers(source: string): string;
-declare function createRealtimeClientDefinitionModule(source: string, importTarget: string): string;
-declare function createRealtimeClientDefinitionTransform(source: string, importTarget: string, options?: RealtimeDefinitionTransformOptions): RealtimeDefinitionTransformResult;
+declare function createRealtimeClientDefinitionModule(input: Omit<RealtimeDefinitionTransformInput, 'preserveServerHandlers'>): string;
+declare function createRealtimeClientDefinitionTransform(input: RealtimeDefinitionTransformInput): RealtimeDefinitionTransformResult;
 
-export { type RealtimeDefinitionSourceMap, type RealtimeDefinitionTransformOptions, type RealtimeDefinitionTransformResult, compileBrowserValidation, compileNextRoute, createRealtimeClientDefinitionModule, createRealtimeClientDefinitionTransform, stripRealtimeServerHandlers };
+export { compileBrowserValidation, compileNextRoute, createRealtimeClientDefinitionModule, createRealtimeClientDefinitionTransform, stripRealtimeServerHandlers };
+export type { RealtimeDefinitionSourceMap, RealtimeDefinitionTransformInput, RealtimeDefinitionTransformOptions, RealtimeDefinitionTransformResult };

package/dist/build.mjs

@@ -4,7 +4,7 @@ import {
   createRealtimeClientDefinitionModule,
   createRealtimeClientDefinitionTransform,
   stripRealtimeServerHandlers
-} from "./chunk-6FHRFQPC.mjs";
+} from "./chunk-YDL2S5BT.mjs";
 export {
   compileBrowserValidation,
   compileNextRoute,

package/dist/{chunk-6FHRFQPC.mjs → chunk-YDL2S5BT.mjs}

@@ -245,41 +245,200 @@ function propertyName(property) {
   if (!("name" in property) || !property.name) return void 0;
   return ts3.isIdentifier(property.name) || ts3.isStringLiteral(property.name) ? property.name.text : void 0;
 }
-function collectRealtimeFactories(sourceFile) {
+var realtimeFactoryExports = /* @__PURE__ */ new Map([
+  ["query", "query"],
+  ["mutation", "mutation"],
+  ["defineRealtimeQuery", "query"],
+  ["defineRealtimeMutation", "mutation"]
+]);
+function referenceRoot(expression) {
+  let current = unwrapExpression(expression);
+  while (ts3.isPropertyAccessExpression(current) || ts3.isElementAccessExpression(current)) {
+    current = unwrapExpression(current.expression);
+  }
+  return ts3.isIdentifier(current) ? current : void 0;
+}
+function boundNames(name) {
+  if (ts3.isIdentifier(name)) return [name.text];
+  return name.elements.flatMap((element) => ts3.isBindingElement(element) ? boundNames(element.name) : []);
+}
+function collectRealtimeBindings(sourceFile, importTarget) {
   const factories = /* @__PURE__ */ new Map([
     ["query", "query"],
     ["mutation", "mutation"]
   ]);
+  const namespaces = /* @__PURE__ */ new Set();
+  const aliases = /* @__PURE__ */ new Set();
   for (const statement of sourceFile.statements) {
-    if (!ts3.isImportDeclaration(statement) || !statement.importClause?.namedBindings) continue;
-    if (!ts3.isStringLiteral(statement.moduleSpecifier) || statement.moduleSpecifier.text !== "@holo-js/realtime") continue;
-    if (!ts3.isNamedImports(statement.importClause.namedBindings)) continue;
-    for (const element of statement.importClause.namedBindings.elements) {
+    if (!ts3.isImportDeclaration(statement) || !statement.importClause || statement.importClause.isTypeOnly) continue;
+    if (!ts3.isStringLiteral(statement.moduleSpecifier) || statement.moduleSpecifier.text !== "@holo-js/realtime" && statement.moduleSpecifier.text !== importTarget) continue;
+    const { name, namedBindings } = statement.importClause;
+    if (name) namespaces.add(name.text);
+    if (namedBindings && ts3.isNamespaceImport(namedBindings)) namespaces.add(namedBindings.name.text);
+    if (!namedBindings || !ts3.isNamedImports(namedBindings)) continue;
+    for (const element of namedBindings.elements) {
+      if (element.isTypeOnly) continue;
       const importedName = element.propertyName?.text ?? element.name.text;
-      if (importedName === "query" || importedName === "mutation") {
-        factories.set(element.name.text, importedName);
+      if (importedName === "default") {
+        namespaces.add(element.name.text);
+        continue;
       }
+      const factory = realtimeFactoryExports.get(importedName);
+      if (factory) factories.set(element.name.text, factory);
     }
   }
-  return factories;
+  for (const statement of sourceFile.statements) {
+    if (!ts3.isVariableStatement(statement)) continue;
+    for (const declaration of statement.declarationList.declarations) {
+      const root = declaration.initializer && referenceRoot(declaration.initializer);
+      if (root && (factories.has(root.text) || namespaces.has(root.text) || aliases.has(root.text))) {
+        for (const name of boundNames(declaration.name)) aliases.add(name);
+      }
+    }
+  }
+  return { factories, namespaces, aliases };
 }
-function collectDefinitions(sourceFile) {
-  const definitions = [];
-  const factories = collectRealtimeFactories(sourceFile);
+function namespaceMember(callee, bindings) {
+  if (!ts3.isPropertyAccessExpression(callee) && !ts3.isElementAccessExpression(callee)) return void 0;
+  const namespace = unwrapExpression(callee.expression);
+  if (!ts3.isIdentifier(namespace) || !bindings.namespaces.has(namespace.text)) return void 0;
+  if (ts3.isPropertyAccessExpression(callee)) return callee.name.text;
+  return ts3.isStringLiteralLike(callee.argumentExpression) ? callee.argumentExpression.text : void 0;
+}
+function resolveFactory(wrappedCallee, bindings) {
+  const callee = unwrapExpression(wrappedCallee);
+  if (ts3.isIdentifier(callee)) return bindings.factories.get(callee.text);
+  const member = namespaceMember(callee, bindings);
+  return member === void 0 ? void 0 : realtimeFactoryExports.get(member);
+}
+function unwrapExpression(expression) {
+  let current = expression;
+  while (ts3.isParenthesizedExpression(current) || ts3.isAsExpression(current) || ts3.isSatisfiesExpression(current) || ts3.isTypeAssertionExpression(current) || ts3.isNonNullExpression(current)) {
+    current = current.expression;
+  }
+  return current;
+}
+function containsFactoryCall(node, bindings) {
+  if (ts3.isCallExpression(node) && resolveFactory(node.expression, bindings)) return true;
+  return ts3.forEachChild(node, (child) => containsFactoryCall(child, bindings) || void 0) ?? false;
+}
+function containsRealtimeReference(node, bindings) {
+  return containsFactoryCall(node, bindings) || referencesName(node, /* @__PURE__ */ new Set([...bindings.namespaces, ...bindings.aliases]));
+}
+function collectStringConstants(sourceFile) {
+  const constants = /* @__PURE__ */ new Map();
   for (const statement of sourceFile.statements) {
-    if (!ts3.isVariableStatement(statement) || !statement.modifiers?.some((modifier) => modifier.kind === ts3.SyntaxKind.ExportKeyword)) continue;
+    if (!ts3.isVariableStatement(statement) || !(statement.declarationList.flags & ts3.NodeFlags.Const) || statement.modifiers?.some((modifier) => modifier.kind === ts3.SyntaxKind.DeclareKeyword)) continue;
     for (const declaration of statement.declarationList.declarations) {
-      if (!ts3.isIdentifier(declaration.name) || !declaration.initializer || !ts3.isCallExpression(declaration.initializer)) continue;
-      const factoryNode = declaration.initializer.expression;
-      if (!ts3.isIdentifier(factoryNode)) continue;
-      const factory = factories.get(factoryNode.text);
-      if (!factory) continue;
-      const definitionNode = declaration.initializer.arguments[0];
-      if (!definitionNode || !ts3.isObjectLiteralExpression(definitionNode)) continue;
-      const nameProperty = definitionNode.properties.find((property) => propertyName(property) === "name");
-      const name = nameProperty && ts3.isPropertyAssignment(nameProperty) ? nameProperty.initializer.getText(sourceFile) : void 0;
-      const sourceLine = sourceFile.getLineAndCharacterOfPosition(declaration.getStart(sourceFile)).line;
-      definitions.push({ exportedName: declaration.name.text, factory, sourceLine, ...name ? { name } : {} });
+      if (ts3.isIdentifier(declaration.name) && declaration.initializer && ts3.isStringLiteralLike(declaration.initializer)) {
+        constants.set(declaration.name.text, declaration.initializer);
+      }
+    }
+  }
+  return constants;
+}
+function definitionKey(property) {
+  if (!property.name) return void 0;
+  if (ts3.isComputedPropertyName(property.name)) {
+    const expression = unwrapExpression(property.name.expression);
+    return ts3.isStringLiteralLike(expression) ? expression.text : void 0;
+  }
+  return ts3.isIdentifier(property.name) || ts3.isStringLiteral(property.name) || ts3.isNumericLiteral(property.name) ? property.name.text : void 0;
+}
+function definitionNameValue(property, constants) {
+  const value = ts3.isShorthandPropertyAssignment(property) ? property.name : ts3.isPropertyAssignment(property) ? unwrapExpression(property.initializer) : void 0;
+  const literal2 = value && (ts3.isStringLiteralLike(value) ? value : ts3.isIdentifier(value) ? constants.get(value.text) : void 0);
+  return literal2 ? { known: true, literal: literal2 } : { known: false };
+}
+function resolveDefinitionName(definitionNode, constants) {
+  let name = { known: true };
+  for (const property of definitionNode.properties) {
+    if (ts3.isSpreadAssignment(property)) {
+      name = { known: false };
+      continue;
+    }
+    const key = definitionKey(property);
+    if (key === "name") {
+      name = definitionNameValue(property, constants);
+    } else if (key === void 0 && property.name && ts3.isComputedPropertyName(property.name)) {
+      name = { known: false };
+    }
+  }
+  return name;
+}
+function referencesName(node, names) {
+  if (ts3.isIdentifier(node) && names.has(node.text)) {
+    const parent = node.parent;
+    const isPropertyName = ts3.isPropertyAccessExpression(parent) && parent.name === node || (ts3.isPropertyAssignment(parent) || ts3.isMethodDeclaration(parent) || ts3.isPropertyDeclaration(parent) || ts3.isGetAccessorDeclaration(parent) || ts3.isSetAccessorDeclaration(parent)) && parent.name === node;
+    if (!isPropertyName) return true;
+  }
+  return ts3.forEachChild(node, (child) => referencesName(child, names) || void 0) ?? false;
+}
+function collectDefinitionLocals(sourceFile, bindings) {
+  const locals = /* @__PURE__ */ new Set();
+  const declarations = sourceFile.statements.filter(ts3.isVariableStatement).flatMap((statement) => [...statement.declarationList.declarations]);
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const declaration of declarations) {
+      if (!declaration.initializer) continue;
+      if (!containsRealtimeReference(declaration.initializer, bindings) && !referencesName(declaration.initializer, locals)) continue;
+      for (const name of boundNames(declaration.name)) {
+        if (!locals.has(name)) {
+          locals.add(name);
+          changed = true;
+        }
+      }
+    }
+  }
+  return locals;
+}
+function unreducibleDefinitionError(filePath, exportedName) {
+  return new Error(`${filePath} exports ${exportedName} through a query or mutation call that cannot be reduced to a browser definition. Export each definition directly, as export const name = query({ name: 'posts.list', ... }) or export default query({ ... }).`);
+}
+function collectDefinitions(sourceFile, filePath, importTarget) {
+  const definitions = [];
+  const bindings = collectRealtimeBindings(sourceFile, importTarget);
+  const constants = collectStringConstants(sourceFile);
+  const definitionLocals = collectDefinitionLocals(sourceFile, bindings);
+  const recordDefinition = (exportedName, expression, node) => {
+    const call = unwrapExpression(expression);
+    const factory = ts3.isCallExpression(call) ? resolveFactory(call.expression, bindings) : void 0;
+    if (!ts3.isCallExpression(call) || !factory) {
+      if (containsRealtimeReference(expression, bindings) || referencesName(expression, definitionLocals)) {
+        throw unreducibleDefinitionError(filePath, exportedName);
+      }
+      return;
+    }
+    const definitionNode = call.arguments[0];
+    if (!definitionNode || !ts3.isObjectLiteralExpression(definitionNode)) throw unreducibleDefinitionError(filePath, exportedName);
+    const name = resolveDefinitionName(definitionNode, constants);
+    if (!name.known) {
+      throw new Error(`${filePath} defines ${exportedName} with a name that is not a string literal, so it cannot be sent to the browser.`);
+    }
+    const sourceLine = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line;
+    definitions.push({ exportedName, factory, sourceLine, ...name.literal ? { name: name.literal.getText(sourceFile) } : {} });
+  };
+  for (const statement of sourceFile.statements) {
+    if (ts3.isVariableStatement(statement)) {
+      if (!statement.modifiers?.some((modifier) => modifier.kind === ts3.SyntaxKind.ExportKeyword)) continue;
+      for (const declaration of statement.declarationList.declarations) {
+        if (!declaration.initializer) continue;
+        if (!ts3.isIdentifier(declaration.name)) {
+          if (boundNames(declaration.name).some((name) => definitionLocals.has(name))) {
+            throw unreducibleDefinitionError(filePath, declaration.name.getText(sourceFile));
+          }
+          continue;
+        }
+        recordDefinition(declaration.name.text, declaration.initializer, declaration);
+      }
+    } else if (ts3.isExportAssignment(statement) && !statement.isExportEquals) {
+      recordDefinition("default", statement.expression, statement);
+    } else if (ts3.isExportDeclaration(statement) && !statement.moduleSpecifier && !statement.isTypeOnly && statement.exportClause && ts3.isNamedExports(statement.exportClause)) {
+      for (const element of statement.exportClause.elements) {
+        const localName = element.propertyName?.text ?? element.name.text;
+        if (!element.isTypeOnly && definitionLocals.has(localName)) throw unreducibleDefinitionError(filePath, element.name.text);
+      }
     }
   }
   return Object.freeze(definitions);
@@ -296,7 +455,7 @@ function encodeVlq(value) {
   } while (remaining > 0);
   return encoded;
 }
-function createSourceMap(source, sourceLines) {
+function createSourceMap(sourceLines, sourcesContent) {
   let previousSourceLine = 0;
   const mappings = sourceLines.map((sourceLine) => {
     if (typeof sourceLine === "undefined") return "";
@@ -308,7 +467,7 @@ function createSourceMap(source, sourceLines) {
     version: 3,
     file: "realtime.client.ts",
     sources: ["realtime.ts"],
-    sourcesContent: [source],
+    ...sourcesContent ? { sourcesContent } : {},
     names: [],
     mappings
   };
@@ -369,36 +528,44 @@ function stripRealtimeServerHandlers(source) {
     result.dispose();
   }
 }
-function createRealtimeClientDefinitionModule(source, importTarget) {
-  return createRealtimeClientDefinitionTransform(source, importTarget).code;
+function createRealtimeClientDefinitionModule(input) {
+  return createRealtimeClientDefinitionTransform(input).code;
 }
-function createRealtimeClientDefinitionTransform(source, importTarget, options = {}) {
-  if (options.preserveServerHandlers) {
+function createRealtimeClientDefinitionTransform(input) {
+  if (typeof input !== "object" || input === null || typeof input.source !== "string" || typeof input.importTarget !== "string" || typeof input.filePath !== "string") {
+    throw new TypeError("createRealtimeClientDefinitionTransform takes one object with source, importTarget, and filePath strings, and an optional preserveServerHandlers flag.");
+  }
+  const { source, importTarget, filePath } = input;
+  if (input.preserveServerHandlers) {
     const code = retargetRealtimeImports(source, importTarget);
     const sourceLineCount = source.split("\n").length;
     return Object.freeze({
       code,
-      map: createSourceMap(source, code.split("\n").map((_, index) => Math.min(index, sourceLineCount - 1)))
+      map: createSourceMap(code.split("\n").map((_, index) => Math.min(index, sourceLineCount - 1)), [source])
     });
   }
   const sourceFile = parseRealtimeSource(source);
-  const definitions = collectDefinitions(sourceFile);
+  const definitions = collectDefinitions(sourceFile, filePath, importTarget);
   if (definitions.length === 0) {
-    const code = stripRealtimeServerHandlers(source);
-    const sourceLineCount = source.split("\n").length;
-    return Object.freeze({
-      code,
-      map: createSourceMap(source, code.split("\n").map((_, index) => Math.min(index, sourceLineCount - 1)))
-    });
+    throw new Error(`${filePath} has no query or mutation definitions, so it cannot be sent to the browser. Keep server-only code out of server/realtime, or move it out of that folder.`);
+  }
+  const exportedNames = new Set(definitions.map((definition) => definition.exportedName));
+  const factoryLocals = /* @__PURE__ */ new Map();
+  for (const definition of definitions) {
+    if (factoryLocals.has(definition.factory)) continue;
+    let local = definition.factory;
+    while (exportedNames.has(local)) local = `_${local}`;
+    factoryLocals.set(definition.factory, local);
   }
-  const factories = [...new Set(definitions.map((definition) => definition.factory))];
+  const importSpecifiers = [...factoryLocals].map(([factory, local]) => factory === local ? factory : `${factory} as ${local}`);
   const outputLines = [
-    `import { ${factories.join(", ")} } from '${importTarget}'`,
+    `import { ${importSpecifiers.join(", ")} } from '${importTarget}'`,
     ""
   ];
   const sourceLines = [void 0, void 0];
   for (const definition of definitions) {
-    outputLines.push(`export const ${definition.exportedName} = ${definition.factory}({`);
+    const factory = factoryLocals.get(definition.factory);
+    outputLines.push(definition.exportedName === "default" ? `export default ${factory}({` : `export const ${definition.exportedName} = ${factory}({`);
     sourceLines.push(definition.sourceLine);
     if (definition.name) {
       outputLines.push(`  name: ${definition.name},`);
@@ -409,7 +576,7 @@ function createRealtimeClientDefinitionTransform(source, importTarget, options =
   }
   return Object.freeze({
     code: outputLines.join("\n"),
-    map: createSourceMap(source, sourceLines)
+    map: createSourceMap(sourceLines)
   });
 }
 

package/dist/client.d.ts

@@ -7,4 +7,5 @@ type ClientErrorPageOptions = {
 };
 declare function renderClientHttpErrorPage(error: NormalizedHoloHttpError, options: ClientErrorPageOptions): void;
 
-export { type ClientErrorPageOptions, renderClientHttpErrorPage };
+export { renderClientHttpErrorPage };
+export type { ClientErrorPageOptions };

package/dist/index.d.ts

@@ -1,3 +1,3 @@
 export { HoloHttpErrorStatus, NormalizedHoloHttpError, isHoloHttpErrorStatus, normalizeHoloHttpError } from '@holo-js/kernel/http-errors';
 export { ClientErrorPageOptions, renderClientHttpErrorPage } from './client.js';
-export { RealtimeDefinitionSourceMap, RealtimeDefinitionTransformOptions, RealtimeDefinitionTransformResult, compileBrowserValidation, compileNextRoute, createRealtimeClientDefinitionModule, createRealtimeClientDefinitionTransform, stripRealtimeServerHandlers } from './build.js';
+export { RealtimeDefinitionSourceMap, RealtimeDefinitionTransformInput, RealtimeDefinitionTransformOptions, RealtimeDefinitionTransformResult, compileBrowserValidation, compileNextRoute, createRealtimeClientDefinitionModule, createRealtimeClientDefinitionTransform, stripRealtimeServerHandlers } from './build.js';

package/dist/index.mjs

@@ -9,7 +9,7 @@ import {
   createRealtimeClientDefinitionModule,
   createRealtimeClientDefinitionTransform,
   stripRealtimeServerHandlers
-} from "./chunk-6FHRFQPC.mjs";
+} from "./chunk-YDL2S5BT.mjs";
 export {
   compileBrowserValidation,
   compileNextRoute,

package/dist/next/request-context.d.ts

@@ -11,4 +11,5 @@ type NextRequestLike = {
 declare function getCurrentNextRequest(): NextRequestLike | undefined;
 declare function runWithNextRequest<TValue>(request: NextRequestLike, callback: () => TValue): TValue;
 
-export { type NextRequestLike, getCurrentNextRequest, runWithNextRequest };
+export { getCurrentNextRequest, runWithNextRequest };
+export type { NextRequestLike };

package/dist/realtime-directories.d.ts

@@ -0,0 +1,5 @@
+declare function assertRealtimeDefinitionTree(rootDir: string): void;
+declare function resolveRealtimeDefinitionDirectories(rootDir: string): readonly string[];
+declare function isInRealtimeDefinitionDirectory(directories: readonly string[], id: string): boolean;
+
+export { assertRealtimeDefinitionTree, isInRealtimeDefinitionDirectory, resolveRealtimeDefinitionDirectories };

package/dist/realtime-directories.mjs

@@ -0,0 +1,57 @@
+// src/realtime-directories.ts
+import { existsSync, readdirSync, realpathSync, statSync } from "fs";
+import { join, posix, relative, resolve, win32 } from "path";
+function normalizeDirectory(path) {
+  return path.replaceAll("\\", "/").replace(/\/+$/, "");
+}
+function resolveConfiguredRoot(rootDir) {
+  return posix.isAbsolute(rootDir) || win32.isAbsolute(rootDir) ? rootDir : resolve(rootDir);
+}
+function symlinkTargetStaysInTree(linkPath, tree) {
+  if (!existsSync(linkPath)) return false;
+  const target = realpathSync.native(linkPath);
+  return statSync(target).isDirectory() && normalizeDirectory(target).startsWith(`${normalizeDirectory(tree)}/`);
+}
+function symlinkError(tree, linkPath) {
+  const displayPath = `server/realtime/${normalizeDirectory(relative(tree, linkPath))}`;
+  const replacement = existsSync(linkPath) && statSync(linkPath).isDirectory() ? "folder" : "file";
+  return new Error(`${displayPath} is a symbolic link; Holo can't guarantee its server code stays out of the browser bundle. Replace it with a regular ${replacement}.`);
+}
+function assertTreeEntries(tree, directory) {
+  for (const entry of readdirSync(directory, { withFileTypes: true })) {
+    const path = join(directory, entry.name);
+    if (entry.isSymbolicLink()) {
+      if (!symlinkTargetStaysInTree(path, tree)) throw symlinkError(tree, path);
+    } else if (entry.isDirectory()) {
+      assertTreeEntries(tree, path);
+    }
+  }
+}
+function assertRealtimeDefinitionTree(rootDir) {
+  const configured = join(resolveConfiguredRoot(rootDir), "server", "realtime");
+  if (!existsSync(configured)) return;
+  const tree = realpathSync.native(configured);
+  assertTreeEntries(tree, tree);
+}
+function resolveRealtimeDefinitionDirectories(rootDir) {
+  const configuredRoot = resolveConfiguredRoot(rootDir);
+  const configured = join(configuredRoot, "server", "realtime");
+  assertRealtimeDefinitionTree(rootDir);
+  const directories = /* @__PURE__ */ new Set([`${normalizeDirectory(configuredRoot)}/server/realtime`]);
+  if (existsSync(configuredRoot)) {
+    directories.add(`${normalizeDirectory(realpathSync.native(configuredRoot))}/server/realtime`);
+  }
+  if (existsSync(configured)) {
+    directories.add(normalizeDirectory(realpathSync.native(configured)));
+  }
+  return [...directories];
+}
+function isInRealtimeDefinitionDirectory(directories, id) {
+  const path = id.split("?")[0].replaceAll("\\", "/");
+  return directories.some((directory) => path.startsWith(`${directory}/`));
+}
+export {
+  assertRealtimeDefinitionTree,
+  isInRealtimeDefinitionDirectory,
+  resolveRealtimeDefinitionDirectories
+};

package/dist/server-errors.d.ts

@@ -10,6 +10,19 @@ type RateLimitFailure = {
     readonly values: Readonly<Record<string, never>>;
     readonly retryAfterSeconds?: number;
 };
+type RequestBodyTooLargeFailure = {
+    readonly ok: false;
+    readonly valid: false;
+    readonly status: 413;
+    readonly bag: 'default';
+    readonly message: string;
+    readonly errors: {
+        readonly _root: readonly string[];
+    };
+    readonly values: Readonly<Record<string, never>>;
+    readonly retryAfterSeconds?: undefined;
+};
+declare function serializeRequestBodyTooLargeError(error: unknown): RequestBodyTooLargeFailure | undefined;
 declare function serializeRateLimitError(error: unknown): RateLimitFailure | undefined;
 
-export { serializeRateLimitError };
+export { serializeRateLimitError, serializeRequestBodyTooLargeError };

package/dist/server-errors.mjs

@@ -1,5 +1,20 @@
 // src/server-errors.ts
-import { normalizeHoloHttpError } from "@holo-js/kernel/http-errors";
+import { HoloRequestBodyTooLargeError, normalizeHoloHttpError } from "@holo-js/kernel";
+function serializeRequestBodyTooLargeError(error) {
+  if (!(error instanceof HoloRequestBodyTooLargeError) && !(error instanceof Error && error.name === "HoloRequestBodyTooLargeError")) {
+    const cause = error && typeof error === "object" && "cause" in error ? error.cause : void 0;
+    return cause === void 0 ? void 0 : serializeRequestBodyTooLargeError(cause);
+  }
+  return {
+    ok: false,
+    valid: false,
+    status: 413,
+    bag: "default",
+    message: error.message,
+    errors: { _root: [error.message] },
+    values: {}
+  };
+}
 function serializeRateLimitError(error) {
   const normalized = normalizeHoloHttpError(error);
   if (!normalized || normalized.status !== 429) return void 0;
@@ -20,5 +35,6 @@ function serializeRateLimitError(error) {
   };
 }
 export {
-  serializeRateLimitError
+  serializeRateLimitError,
+  serializeRequestBodyTooLargeError
 };

package/dist/sveltekit/request-context.d.ts

@@ -3,11 +3,15 @@ type SvelteKitRequestEvent = {
     readonly cookies: {
         get(name: string): string | undefined;
         set(name: string, value: string, options: SvelteKitCookieOptions): void;
+        delete(name: string, options: {
+            readonly path: string;
+        }): void;
     };
     readonly request: {
         readonly method?: string;
         readonly headers: Headers;
     };
+    readonly getClientAddress?: () => string;
 };
 type SvelteKitCookieOptions = {
     path: string;
@@ -22,4 +26,5 @@ type SvelteKitCookieOptions = {
 declare function getCurrentSvelteKitRequestEvent(): SvelteKitRequestEvent | undefined;
 declare function runWithSvelteKitRequestEvent<TValue>(event: SvelteKitRequestEvent, callback: () => TValue): TValue;
 
-export { type SvelteKitRequestEvent, getCurrentSvelteKitRequestEvent, runWithSvelteKitRequestEvent };
+export { getCurrentSvelteKitRequestEvent, runWithSvelteKitRequestEvent };
+export type { SvelteKitRequestEvent };

package/package.json

@@ -1,10 +1,20 @@
 {
   "name": "@holo-js/adapter-shared",
-  "version": "0.3.28",
+  "version": "0.4.1",
   "description": "Holo-JS Framework - shared framework adapter infrastructure",
   "type": "module",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cobraprojects/holo-js.git",
+    "directory": "packages/adapter-shared"
+  },
   "exports": {
+    "./realtime-directories": {
+      "types": "./dist/realtime-directories.d.ts",
+      "import": "./dist/realtime-directories.mjs",
+      "default": "./dist/realtime-directories.mjs"
+    },
     "./server-errors": {
       "types": "./dist/server-errors.d.ts",
       "import": "./dist/server-errors.mjs",
@@ -42,7 +52,8 @@
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
   "files": [
-    "dist"
+    "dist",
+    "LICENSE"
   ],
   "scripts": {
     "build": "tsup",
@@ -51,14 +62,14 @@
     "test": "vitest --run"
   },
   "dependencies": {
-    "@holo-js/kernel": "^0.3.28",
-    "typescript": "^5.7.2"
+    "@holo-js/kernel": "^0.4.1",
+    "typescript": "^6.0.3"
   },
   "devDependencies": {
-    "tsup": "^8.3.5",
-    "vitest": "^4.1.5"
+    "tsup": "^9.0.0",
+    "vitest": "^5.0.5"
   },
   "engines": {
-    "node": "^22.12.0 || ^24.0.0 || ^26.0.0"
+    "node": "^22.18.0 || ^24.0.0 || ^26.0.0"
   }
 }