akanjs 3.1.0-rc.2 → 3.1.0-rc.21

package/constant/inputParser.ts

@@ -0,0 +1,148 @@
+import {
+  Any,
+  type Cls,
+  dayjs,
+  type EnumInstance,
+  FIELD_META,
+  Float,
+  getNonArrayModel,
+  ID,
+  Int,
+  PrimitiveRegistry,
+  type PrimitiveScalar,
+} from "akanjs/base";
+
+import { ConstantRegistry } from "./constantRegistry";
+import type { ConstantField, FieldObject } from "./fieldInfo";
+import { FieldPlan, type FieldPlanEntry } from "./fieldPlan";
+import { defaultPlanOf } from "./getDefault";
+import { InvalidInputError } from "./invalidInputError";
+import { deserialize } from "./serialize";
+
+type ModelCls = Cls & { [FIELD_META]: FieldObject };
+type Parse = (value: unknown, path: string) => unknown;
+
+interface ParseOption {
+  key: string;
+  nullable?: boolean;
+  enum?: EnumInstance;
+}
+
+const isString = (value: unknown) => typeof value === "string";
+const isNumber = (value: unknown) => typeof value === "number";
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
+export class InputParser {
+  
+  static readonly #wireTypes = new Map<unknown, (value: unknown) => boolean>([
+    [String, isString],
+    [ID, isString],
+    [Int, isNumber],
+    [Float, isNumber],
+    [Boolean, (value) => typeof value === "boolean"],
+    [Date, (value) => isString(value) || isNumber(value) || value instanceof Date || dayjs.isDayjs(value)],
+  ]);
+
+  static parse(argRef: Cls, arrDepth: number, value: unknown, option: ParseOption) {
+    if (PrimitiveRegistry.has(argRef)) return deserialize(argRef, arrDepth, value, option);
+    const { key, nullable = false } = option;
+    if (value === null || value === undefined) {
+      if (nullable) return null;
+      throw new InvalidInputError(key, null);
+    }
+    return InputParser.#walk(value, arrDepth, key, (item, path) => InputParser.#value(argRef, item, path));
+  }
+
+  static #walk(value: unknown, arrDepth: number, path: string, parse: Parse): unknown {
+    if (!arrDepth) return parse(value, path);
+    if (!Array.isArray(value)) throw new InvalidInputError(path, "array");
+    return value.map((item, idx) => InputParser.#walk(item, arrDepth - 1, `${path}.${idx}`, parse));
+  }
+
+  static #value(ref: Cls, value: unknown, path: string, enumRef?: EnumInstance): unknown {
+    if (value === null || value === undefined) {
+      if (ref === Any) return value ?? null;
+      throw new InvalidInputError(path, null);
+    }
+    if (PrimitiveRegistry.has(ref)) return InputParser.#primitive(ref as typeof PrimitiveScalar, value, path, enumRef);
+    if (ConstantRegistry.isScalar(ref)) return InputParser.#scalar(ref as ModelCls, value, path);
+    return InputParser.#model(ref as ModelCls, value, path);
+  }
+
+  static #primitive(primitive: typeof PrimitiveScalar, value: unknown, path: string, enumRef?: EnumInstance) {
+    const hasWireType = InputParser.#wireTypes.get(primitive);
+    if (hasWireType && !hasWireType(value)) throw new InvalidInputError(path, primitive.refName);
+    let parsed: unknown;
+    try {
+      parsed = primitive._parse(value as never);
+    } catch {
+      throw new InvalidInputError(path, primitive.refName);
+    }
+    if (enumRef && !enumRef.has(parsed as never))
+      throw new InvalidInputError(path, `one of ${enumRef.values.join(", ")}`);
+    return parsed;
+  }
+
+  static #scalar(ref: ModelCls, value: unknown, path: string) {
+    if (!isRecord(value)) throw new InvalidInputError(path, "object");
+    const defaults = defaultPlanOf(ref[FIELD_META]);
+    const parsed: Record<string, unknown> = {};
+    for (const entry of FieldPlan.of(ref).entries) {
+      if (entry.kind === "computed") continue;
+      const fieldPath = `${path}.${entry.key}`;
+      const raw = value[entry.key];
+      if (raw !== undefined) parsed[entry.key] = InputParser.#field(entry, raw, fieldPath);
+      else if (InputParser.#isRequired(entry.field)) throw new InvalidInputError(fieldPath, null);
+      else {
+        const make = defaults.perCall.get(entry.key);
+        parsed[entry.key] = make ? make() : defaults.shared[entry.key];
+      }
+    }
+    return parsed;
+  }
+
+  static #model(ref: ModelCls, value: unknown, path: string) {
+    if (!isRecord(value)) throw new InvalidInputError(path, "object");
+    const parsed: Record<string, unknown> = {};
+    for (const entry of FieldPlan.of(ref).entries) {
+      if (entry.kind === "computed") continue;
+      const fieldPath = `${path}.${entry.key}`;
+      const raw = value[entry.key];
+      if (raw !== undefined) parsed[entry.key] = InputParser.#field(entry, raw, fieldPath);
+      else if (InputParser.#isRequired(entry.field)) throw new InvalidInputError(fieldPath, null);
+    }
+    return parsed;
+  }
+
+  static #field({ field, isRelationRef }: FieldPlanEntry, value: unknown, path: string): unknown {
+    if (value === null) {
+      if (field.nullable || (field.modelRef as Cls) === Any) return null;
+      throw new InvalidInputError(path, null);
+    }
+    return InputParser.#walk(value, field.arrDepth, path, (item, itemPath) => {
+      if (field.isMap) return InputParser.#map(field.of as Cls | Cls[], item, itemPath);
+      if (isRelationRef) return InputParser.#value(ID, item, itemPath);
+      return InputParser.#value(field.modelRef, item, itemPath, field.enum);
+    });
+  }
+
+  static #map(of: Cls | Cls[], value: unknown, path: string) {
+    if (!isRecord(value)) throw new InvalidInputError(path, "object");
+    const [valueRef, valueArrDepth] = getNonArrayModel(of);
+    return Object.fromEntries(
+      Object.entries(value).map(([key, item]) => [
+        key,
+        InputParser.#walk(item, valueArrDepth, `${path}.${key}`, (entry, entryPath) =>
+          InputParser.#value(valueRef as Cls, entry, entryPath),
+        ),
+      ]),
+    );
+  }
+
+  static #isRequired(field: ConstantField) {
+    if (field.nullable || (field.modelRef as Cls) === Any) return false;
+    if (field.default !== null && field.default !== undefined) return false;
+    return !(field.isClass && field.isScalar);
+  }
+}

package/constant/invalidInputError.ts

@@ -0,0 +1,13 @@
+/** A body value the request schema refuses: `path` names it from the argument down (`data.items.2.price`). */
+export class InvalidInputError extends Error {
+  readonly path: string;
+  readonly reason: "missing" | "invalid";
+  /** What the field takes — a type name, `object`, `array`, or the enum's values; `null` when it is missing. */
+  readonly expected: string | null;
+  constructor(path: string, expected: string | null) {
+    super(expected ? `Invalid input at ${path}: expected ${expected}` : `Missing input at ${path}`);
+    this.path = path;
+    this.reason = expected ? "invalid" : "missing";
+    this.expected = expected;
+  }
+}

package/constant/serialize.ts

@@ -12,6 +12,7 @@ import {
 } from "akanjs/base";
 
 import { type ConstantCls, type ConstantModelRef, ConstantRegistry, type FieldProps, withSharedInstances } from ".";
+import { FieldPlan } from "./fieldPlan";
 
 export type Serialized<O> = O extends (infer V)[]
   ? Serialized<V>[]
@@ -27,12 +28,14 @@ const getSerializeFn = (inputRef: Cls, { optional = false }: { optional?: boolea
   PrimitiveRegistry.has(inputRef)
     ? (value: unknown) => (inputRef as typeof PrimitiveScalar)._serialize(value as never, { optional })
     : (value: unknown) => value as object;
+const optionalSerialize = { optional: true } as const;
+const requiredSerialize = { optional: false } as const;
 const serializeInput = <Input = unknown>(
   value: Input | Input[],
   inputRef: ConstantModelRef<Input> | PrimitiveScalar,
   arrDepth: number,
   serializeType: "input" | "object" = "object",
-  { optional = false }: { optional?: boolean } = {},
+  optional = false,
 ): Input | Input[] => {
   if (arrDepth && Array.isArray(value))
     return value.map((v) => serializeInput(v, inputRef, arrDepth - 1, serializeType) as Input) as unknown as Input[];
@@ -46,24 +49,23 @@ const serializeInput = <Input = unknown>(
       ]),
     ) as unknown as Input;
   } else if (PrimitiveRegistry.has(inputRef as Cls)) {
-    const serializeFn = getSerializeFn(inputRef as Cls, { optional });
-    return serializeFn(value) as Input;
+    return (inputRef as typeof PrimitiveScalar)._serialize(
+      value as never,
+      optional ? optionalSerialize : requiredSerialize,
+    ) as Input;
   } else {
-    const modelRef = inputRef as ConstantCls;
-    return Object.fromEntries(
-      Object.entries(modelRef[FIELD_META]).map(([key, field]) => [
-        key,
-        serializeType === "input" && field.isClass && !field.isScalar
-          ? serialize(ID, field.arrDepth, getRelationId((value as Record<string, unknown>)?.[key]), serializeType, {
-              nullable: field.nullable,
-              key,
-            })
-          : serialize(field.modelRef, field.arrDepth, (value as Record<string, unknown>)?.[key], serializeType, {
-              nullable: field.nullable,
-              key,
-            }),
-      ]),
-    ) as unknown as Input;
+    const serialized: Record<string, unknown> = {};
+    for (const { key, field, isRelationRef, primitive, serializeOption } of FieldPlan.of(inputRef as ConstantCls)
+      .entries) {
+      const fieldValue = (value as Record<string, unknown> | null | undefined)?.[key];
+      serialized[key] =
+        primitive && !field.arrDepth
+          ? serializePrimitive(primitive, fieldValue, serializeOption)
+          : serializeType === "input" && isRelationRef
+            ? serialize(ID, field.arrDepth, getRelationId(fieldValue), serializeType, serializeOption)
+            : serialize(field.modelRef, field.arrDepth, fieldValue, serializeType, serializeOption);
+    }
+    return serialized as unknown as Input;
   }
 };
 
@@ -82,9 +84,23 @@ export const serialize = (
 ) => {
   if (nullable && (value === null || value === undefined)) return null;
   else if (!nullable && (value === null || value === undefined) && argRef !== Any)
-    throw new Error(`Invalid Value (Nullable) in ${argRef} for value ${value}${key ? ` in ${key}` : ""}`);
-  return serializeInput(value, argRef, arrDepth, serializeType, { optional: nullable }) as object[];
+    throw missingValueError(argRef, value, key);
+  return serializeInput(value, argRef, arrDepth, serializeType, nullable) as object[];
+};
+
+const serializePrimitive = (
+  primitive: typeof PrimitiveScalar,
+  value: unknown,
+  { nullable, key }: { nullable: boolean; key: string },
+) => {
+  if (value === null || value === undefined) {
+    if (nullable) return null;
+    if ((primitive as unknown) !== Any) throw missingValueError(primitive, value, key);
+  }
+  return primitive._serialize(value as never, nullable ? optionalSerialize : requiredSerialize);
 };
+const missingValueError = (argRef: unknown, value: unknown, key?: string) =>
+  new Error(`Invalid Value (Nullable) in ${argRef} for value ${value}${key ? ` in ${key}` : ""}`);
 
 const getDeserializeFn = (inputRef: ConstantModelRef | PrimitiveScalar) =>
   PrimitiveRegistry.has(inputRef as Cls)

package/constant/types.ts

@@ -1,6 +1,6 @@
 import { type Dayjs, dayjs, enumOf, type GetStateObject } from "akanjs/base";
 
-export type QueryOf<T = any> = any;
+export type QueryOf<_T = any> = any;
 
 export type ConstantType = "input" | "object" | "full" | "light" | "insight" | "scalar";
 

package/constant/via.ts

@@ -29,6 +29,7 @@ import {
   field,
   resolve,
 } from "./fieldInfo";
+import { FieldPlan } from "./fieldPlan";
 import { HydrationPlan } from "./hydrationPlan";
 import { makePurify, type PurifiedModel, type PurifyFunc } from "./purify";
 import { TextFieldPaths } from "./textFieldPaths";
@@ -422,6 +423,7 @@ const applyConstantStatics = <Model>(model: ConstantCls<Model>, fieldMap: FieldO
   for (const [key, field] of Object.entries(model[FIELD_META]))
     if (isDateSlotField(field.getProps())) Object.defineProperty(model.prototype, key, dateAccessorOf(key));
   HydrationPlan.reset(model);
+  FieldPlan.reset(model);
   return model as unknown as ConstantCls<Model>;
 };
 

package/dictionary/base.dictionary.ts

@@ -49,6 +49,10 @@ export const baseDictionary = serviceDictionary(["en", "ko"])
       "서버가 예상하지 못한 응답을 보냈습니다. ({status})",
     ],
     immutableField: ["{field} cannot be changed after creation.", "{field}은(는) 생성 후에는 바꿀 수 없습니다."],
+    invalidArgument: ["{name} has an invalid value.", "{name} 값이 올바르지 않습니다."],
+    requiredArgument: ["{name} is required.", "{name}은(는) 필수 값입니다."],
+    invalidField: ["{field} has an invalid value.", "{field} 값이 올바르지 않습니다."],
+    documentNotFound: ["The requested item does not exist.", "요청한 항목을 찾을 수 없습니다."],
     relationNotFound: [
       "The {model} that {field} refers to no longer exists.",
       "{field}이(가) 가리키는 {model}을(를) 찾을 수 없습니다.",

package/dictionary/trans.ts

@@ -65,6 +65,7 @@ export type ErrConstructor<ErrorKey extends string> = {
   new (key: ErrorKey, data?: TranslationData, option?: ErrRestoreOption): ErrInstance;
   prototype: ErrInstance;
   fromJSON(payload: ErrPayload): ErrInstance;
+  is<Key extends ErrorKey>(error: unknown, ...keys: Key[]): error is ErrInstance & { readonly error: Key };
   BadRequest: new (key: ErrorKey, data?: TranslationData, option?: ErrRestoreOption) => ErrInstance;
   Unauthorized: new (key: ErrorKey, data?: TranslationData, option?: ErrRestoreOption) => ErrInstance;
   Forbidden: new (key: ErrorKey, data?: TranslationData, option?: ErrRestoreOption) => ErrInstance;
@@ -150,6 +151,13 @@ export const makeTrans = <
       return new Err(payload.error as _ErrorKey, payload.data, payload);
     }
 
+    /** An Akan error, and one of `keys` when any are named; read off `error`, so a restored remote one passes too. */
+    static is<Key extends _ErrorKey>(error: unknown, ...keys: Key[]): error is ErrInstance & { readonly error: Key } {
+      if (typeof error !== "object" || error === null) return false;
+      const key = (error as { error?: unknown }).error;
+      return typeof key === "string" && (!keys.length || (keys as string[]).includes(key));
+    }
+
     static BadRequest = class BadRequestErr extends Err {
       static override status = 400;
     };

package/document/database.ts

@@ -1,5 +1,5 @@
 import type { MergedValues } from "akanjs/base";
-import { Logger } from "akanjs/common";
+import type { Logger } from "akanjs/common";
 import type { DocumentModel, QueryOf } from "akanjs/constant";
 import type { CacheAdaptor, CacheSetOptions, CacheValue } from "akanjs/service";
 import type { DataLoader } from "./dataLoader";
@@ -8,14 +8,11 @@ import type { ExtractQuery, ExtractSort, FilterInstance } from "./filterMeta";
 import type { Mdl, SaveEventListener, SaveEventType, UpdateResult } from "./into";
 import type { DataInputOf, FindQueryOption, ListQueryOption } from "./types";
 
-export class CacheDatabase<T = unknown> {
-  private logger: Logger;
+export class CacheDatabase<_T = unknown> {
   constructor(
     private readonly refName: string,
     private readonly cache: CacheAdaptor,
-  ) {
-    this.logger = new Logger(`${refName}Cache`);
-  }
+  ) {}
   async set(topic: string, key: string, value: CacheValue, option: CacheSetOptions = {}) {
     await this.cache.set(this.refName, `${topic}:${key}`, value, option);
   }

package/document/documentSchema.ts

@@ -105,4 +105,4 @@ export class DocumentSchema<Doc = unknown> {
 
 export type SchemaOf<Mdl = unknown, Doc = unknown> = DocumentSchema<Doc> & { readonly __model?: Mdl };
 
-export const getDefaultSchemaOptions = <TSchema, TDocument>() => new DocumentSchema<TDocument>();
+export const getDefaultSchemaOptions = <_TSchema, TDocument>() => new DocumentSchema<TDocument>();

package/document/noDocumentError.ts

@@ -1,7 +1,12 @@
 /**
  * A `pick` or `get` that matched nothing, so a caller can tell a missing document from a failure. Callers match on
- * the message; `statusCode` does not reach HTTP (`isExceptionLike` also wants a `toJSON`), where it stays a 500.
+ * the message, which names the table and the id or query; the wire carries only the dictionary key, as a 404.
  */
 export class NoDocumentError extends Error {
   readonly statusCode = 404;
+  readonly error = "base.error.documentNotFound";
+
+  toJSON() {
+    return { error: this.error, statusCode: this.statusCode };
+  }
 }

package/fetch/client/fetchClient.ts

@@ -7,6 +7,7 @@ import {
   type RetryPolicy,
   readAuthToken,
   resolveFileUploadCapability,
+  trimTrailingSlashes,
 } from "akanjs/common";
 import { type BaseInsight, type BaseObject, ConstantRegistry, deserialize, serialize } from "akanjs/constant";
 import type {
@@ -377,7 +378,7 @@ export class FetchClient {
     }
   }
   static #normalizeOrigin(origin: string) {
-    return origin.replace(/\/+$/, "");
+    return trimTrailingSlashes(origin);
   }
   static #sameOrigin(a: string, b: string) {
     return FetchClient.#normalizeOrigin(a) === FetchClient.#normalizeOrigin(b);

package/fetch/client/sliceInitHandle.ts

@@ -63,9 +63,8 @@ export class SliceInitHandle {
 
   #serverInitOf(modelObjList: BaseObject[], modelObjInsight: BaseInsight | null) {
     const { refName, capRefName, sliceName, argLength, queryArgs, page, limit, sort } = this.#input;
-    const lastPage = modelObjInsight?.count
-      ? Math.max(Math.floor((modelObjInsight.count - 1) / (limit || 20)) + 1, 1)
-      : 1;
+    const lastPage =
+      modelObjInsight?.count && limit > 0 ? Math.max(Math.floor((modelObjInsight.count - 1) / limit) + 1, 1) : 1;
     this.#serverInit ??= {
       refName,
       sliceName,

package/fetch/fetchType/appliedReturn.type.ts

@@ -1,10 +1,12 @@
 import type { DataList, GetStateObject, PromiseOrObject } from "akanjs/base";
 import type { ExtractSort, FilterInstance } from "akanjs/document";
 
-export type SliceMeta = {
+export type SliceMeta<Sort = unknown> = {
   refName: string;
   sliceName: string;
   argLength: number;
+  /** Type-only, never set: the slice filter's sort keys, which a `sort` passed beside this meta narrows to. */
+  _Sort?: Sort;
 };
 
 /** What the root slice takes: one of the model's declared filter queries, and the args that filter asks for. */

package/fetch/types.ts

@@ -1,5 +1,5 @@
 import { type Environment, getEnv, type SLICE_META } from "akanjs/base";
-import type { DatabaseSignal } from "akanjs/signal";
+import type { DatabaseSignal, SlceDbSort } from "akanjs/signal";
 import type { SliceMeta } from "./fetchType/appliedReturn.type";
 
 export type Account<AddData = unknown> = {
@@ -17,7 +17,9 @@ type GetSliceMetaObjFromSignal<Signal> = Signal extends {
   ? SliceMetaObj
   : Signal extends DatabaseSignal
     ? {
-        [K in `${Signal["slice"]["baseName"]}${Capitalize<keyof Signal["slice"][typeof SLICE_META] & string>}`]: SliceMeta;
+        [K in `${Signal["slice"]["baseName"]}${Capitalize<keyof Signal["slice"][typeof SLICE_META] & string>}`]: SliceMeta<
+          SlceDbSort<Signal["slice"]>
+        >;
       }
     : Record<never, never>;
 export type GetSliceMetaObjFromDatabaseSignals<

package/index.ts

@@ -601,6 +601,8 @@ export interface AppInfo {
   readonly service: Map<string, Set<string>>;
   readonly scalar: Map<string, Set<string>>;
   readonly file: FileConventionScanSets;
+  /** `script/migration/*.ts` by id, each with its source's sha256. */
+  readonly migrations: readonly { id: string; checksum: string }[];
   getLibs(): string[];
   getLibInfos(): Map<string, LibInfo>;
   getDatabaseModules(): string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akanjs",
-  "version": "3.1.0-rc.2",
+  "version": "3.1.0-rc.21",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {
@@ -225,34 +225,44 @@
       "types": "./types/server/hmr/runtimeMetadataFile.d.ts",
       "import": "./server/hmr/runtimeMetadataFile.ts",
       "default": "./server/hmr/runtimeMetadataFile.ts"
+    },
+    "./server/migration/migrationCommand": {
+      "types": "./types/server/migration/migrationCommand.d.ts",
+      "import": "./server/migration/migrationCommand.ts",
+      "default": "./server/migration/migrationCommand.ts"
+    },
+    "./server/migration/migrationError": {
+      "types": "./types/server/migration/migrationError.d.ts",
+      "import": "./server/migration/migrationError.ts",
+      "default": "./server/migration/migrationError.ts"
     }
   },
   "dependencies": {
-    "@lexical/plain-text": "^0.51.0",
+    "@lexical/plain-text": "^0.52.0",
     "@noble/ciphers": "^2.4.0",
-    "dayjs": "^1.11.20",
-    "immer": "^11.1.8",
-    "lexical": "^0.51.0",
-    "tailwind-merge": "^3.3.1",
-    "tailwind-variants": "^3.3.0"
+    "dayjs": "^1.11.23",
+    "immer": "^11.1.21",
+    "lexical": "^0.52.0",
+    "tailwind-merge": "^3.7.0",
+    "tailwind-variants": "^3.3.1"
   },
   "peerDependencies": {
-    "@happy-dom/global-registrator": "^20.11.2",
-    "@playwright/test": "^1.60.0",
-    "@react-spring/web": "^10.1.0",
+    "@happy-dom/global-registrator": "^21.0.3",
+    "@playwright/test": "^1.64.1",
+    "@react-spring/web": "^10.1.2",
     "@use-gesture/react": "^10.3.1",
-    "bullmq": "^5.76.10",
+    "bullmq": "^5.81.5",
     "chance": "^1.1.13",
-    "firebase": "^12.13.0",
-    "happy-dom": "^20.11.2",
-    "ioredis": "^5.10.1",
+    "firebase": "^13.0.0",
+    "happy-dom": "^21.0.3",
+    "ioredis": "^5.11.1",
     "postgres": "^3.4.9",
-    "protobufjs": "^8.4.0",
-    "react": "19.3.0",
-    "react-dom": "19.3.0",
-    "react-icons": "^5.6.0",
+    "protobufjs": "^8.8.1",
+    "react": "19.3.1",
+    "react-dom": "19.3.1",
+    "react-icons": "^5.7.0",
     "react-refresh": "^0.19.0",
-    "react-server-dom-webpack": "^19.3.0",
+    "react-server-dom-webpack": "^19.3.1",
     "react-spring": "^10.0.4",
     "scheduler": "^0.28.0",
     "tailwind-scrollbar": "^4.0.2",
@@ -321,8 +331,8 @@
     }
   },
   "devDependencies": {
-    "@biomejs/biome": "2.5.12",
-    "@types/bun": "^1.4.2"
+    "@biomejs/biome": "2.5.14",
+    "@types/bun": "^1.4.3"
   },
   "bun": {
     "platform": "bun"

package/server/akanApp.ts

@@ -19,6 +19,7 @@ import { LogHub } from "./logging/logHub";
 import { LogStreamRoute } from "./logging/logStreamRoute";
 import { RotatingLogWriter } from "./logging/rotatingLogWriter";
 import { AppInfo } from "./ops/appInfo";
+import type { OpsHost } from "./ops/opsCommand";
 import type { OpsRoute } from "./ops/opsRoute";
 import { ProcessMetricsCollector } from "./processMetricsCollector";
 import { HostAllowlist } from "./routing/hostAllowlist";
@@ -238,7 +239,9 @@ export class AkanApp {
   async start() {
     if (process.argv[2] === "ops") {
       const { OpsCommand } = await import("./ops/opsCommand");
-      process.exit(await OpsCommand.run(process.argv.slice(3)));
+      process.exit(
+        await OpsCommand.run(process.argv.slice(3), { importServer: async () => await this.#importServer() }),
+      );
     }
     if (this.#solo) return await this.#startSolo();
     if (SelfExec.carried)
@@ -274,6 +277,12 @@ export class AkanApp {
     });
   }
 
+  async #importServer() {
+    Object.assign(process.env, this.#childEnv(0, this.#getRole(0)), { AKAN_COMMAND_TYPE: "script" });
+    resetEnvCache();
+    return (await import(this.#serverPath)) as Awaited<ReturnType<OpsHost["importServer"]>>;
+  }
+
   async #startSolo() {
     const role = this.#getRole(0);
     
@@ -760,7 +769,7 @@ export class AkanApp {
 
   async #proxyHttp(req: Request, server: Bun.Server<GatewayWsData>): Promise<Response> {
     const child = await this.#pickReadyFederationChild(req);
-    if (!child?.upstream || child.upstream.type !== "unix") return this.#respondWithUnavailable(req);
+    if (child?.upstream?.type !== "unix") return this.#respondWithUnavailable(req);
     
     const { socketPath } = child.upstream;
     const url = new URL(req.url);
@@ -800,10 +809,13 @@ export class AkanApp {
     }
   }
 
+  static readonly #upstreamOpenFailureCodes = new Set(["FailedToOpenSocket", "ENOENT", "ECONNREFUSED", "ENOTSOCK"]);
+
   static #isUpstreamOpenFailure(error: unknown): boolean {
     if (!error || typeof error !== "object") return false;
     const candidate = error as { code?: unknown; message?: unknown };
-    return candidate.code === "FailedToOpenSocket" || String(candidate.message ?? "").includes("FailedToOpenSocket");
+    if (typeof candidate.code === "string" && AkanApp.#upstreamOpenFailureCodes.has(candidate.code)) return true;
+    return String(candidate.message ?? "").includes("FailedToOpenSocket");
   }
 
   static #isUpstreamMidFlightClose(error: unknown): boolean {