@crvouga/mockingbird-service-emqx 0.4.0 → 0.6.0

package/CHANGELOG.md

@@ -1,6 +1,18 @@
 # Changelog — @crvouga/mockingbird-service-emqx
 
-## 0.4.0 (2026-10-16)
+## 0.6.0 (2026-10-19)
+
+### Features
+
+- resolve the agent-reported issue queue in one batch ([25c52b6](https://github.com/crvouga/mockingbird/commit/25c52b668a53ddb80b968419601a20abf33f956b))
+
+## 0.5.0 (2026-10-16)
+
+### Features
+
+- resolve fleet and emulator issue batch ([26d2f8c](https://github.com/crvouga/mockingbird/commit/26d2f8cee99fefed93192204bac44fb1be35c1da))
+
+## 0.4.0 (2026-10-15)
 
 ### Features
 

package/dist/{chunk-F6A6NHJ6.js → chunk-NB5GDNQB.js}

@@ -4,20 +4,31 @@ import {
   createRuntime,
   normalizeBootControls,
   normalizeControls,
+  normalizeIdBase,
   ownedTransport,
   parseDuration,
   parseFaultHeader,
   resolveAdminPrefix,
   restoreClock
-} from "./chunk-X2C4CFIC.js";
+} from "./chunk-YXGEJYVV.js";
 
 // ../../adapters/node/dist/cli.js
 import { readFile as readFile5 } from "node:fs/promises";
-import { createRequire as createRequire3 } from "node:module";
-import { resolve as resolve3 } from "node:path";
-import { pathToFileURL } from "node:url";
 import { parseArgs } from "node:util";
 
+// ../../adapters/node/dist/boot-settings.js
+var checkSettings = (target, settings, label) => {
+  if (!target.parseSettings)
+    throw new Error(`${label}: ${target.name} takes no boot settings`);
+  try {
+    return target.parseSettings(settings);
+  } catch (error) {
+    throw new Error(`${label}: ${error instanceof Error ? error.message : String(error)}`, {
+      cause: error
+    });
+  }
+};
+
 // ../../adapters/node/dist/fleet.js
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
 import { createHash as createHash4, randomUUID as randomUUID4 } from "node:crypto";
@@ -29,6 +40,31 @@ import { createHash as createHash3, randomBytes, randomUUID as randomUUID3 } fro
 
 // ../../adapters/node/dist/fleet-archive.js
 import { createHash } from "node:crypto";
+function validateCompatibilityTags(tags) {
+  if (!tags || typeof tags !== "object" || Array.isArray(tags))
+    throw new Error("invalid archive compatibility tags");
+  const entries = Object.entries(tags);
+  if (entries.length > 32 || entries.some(([key, value]) => !/^[A-Za-z0-9_.-]{1,64}$/.test(key) || typeof value !== "string" || value.length < 1 || value.length > 256 || [...value].some((character) => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127)))
+    throw new Error("invalid archive compatibility tags");
+}
+function assertCompatibilityTags(tags, policy) {
+  if (tags !== void 0)
+    validateCompatibilityTags(tags);
+  if (!policy)
+    return;
+  validateCompatibilityTags(policy.tags);
+  if (policy.missing !== void 0 && !["allow", "reject"].includes(policy.missing))
+    throw new Error("invalid missing compatibility policy");
+  if (tags === void 0 && policy.missing === "allow")
+    return;
+  if (canonical(tags) !== canonical(policy.tags))
+    throw new Error("application archive compatibility mismatch");
+}
+function assertArchiveCompatibility(input, policy) {
+  const archive = validateArchive(input);
+  assertCompatibilityTags(archive.compatibility, policy);
+  return archive;
+}
 var canonical = (value) => {
   if (Array.isArray(value))
     return `[${value.map(canonical).join(",")}]`;
@@ -48,6 +84,8 @@ function validateArchive(value) {
   const { sha256, ...content } = doc;
   if (doc.format !== "mockingbird.fleet/v1" || typeof doc.sourceId !== "string" || typeof doc.createdAt !== "string" || !doc.namespaces || typeof doc.namespaces !== "object" || Array.isArray(doc.namespaces) || sha256 !== digest(content))
     throw new Error("unsupported or corrupt fleet archive");
+  if (doc.compatibility !== void 0)
+    validateCompatibilityTags(doc.compatibility);
   for (const [namespace, entry] of Object.entries(doc.namespaces)) {
     if (!/^[A-Za-z0-9_.-]{1,64}$/.test(namespace) || !entry || !Number.isFinite(entry.clock?.now) || typeof entry.clock?.frozen !== "boolean" || !entry.services || !Object.keys(entry.services).length)
       throw new Error("invalid archive namespace");
@@ -63,6 +101,7 @@ function inspectArchive(input) {
     format: archive.format,
     createdAt: archive.createdAt,
     sha256: archive.sha256,
+    ...archive.compatibility ? { compatibility: archive.compatibility } : {},
     namespaces: Object.fromEntries(Object.entries(archive.namespaces).map(([name, ns]) => [
       name,
       {
@@ -705,11 +744,28 @@ var ingressSupport = {
     streaming: true,
     signing: "vendor request signing is not used; webhook signatures remain payload based"
   },
+  cognito: {
+    publicOrigin: true,
+    pathPrefix: true,
+    namespaces: "path-or-header",
+    streaming: true,
+    signing: "JWT issuer and JWKS use the configured public namespace; SigV4 verification is not modelled"
+  },
+  medplum: {
+    publicOrigin: true,
+    pathPrefix: true,
+    namespaces: "path-or-header",
+    streaming: true,
+    signing: "FHIR, OAuth and storage URLs use the configured public namespace"
+  },
   other: {
     publicOrigin: false,
     reason: "host/path-sensitive signing and hosted URL rewriting are not certified; use a direct endpoint"
   }
 };
+function supportsPublicIngress(service) {
+  return service === "stripe" || service === "cognito" || service === "medplum";
+}
 function advertisedHttpBase(entry) {
   if (entry.publicPath !== void 0 && !entry.publicOrigin)
     throw new Error("publicPath requires publicOrigin");
@@ -1248,7 +1304,7 @@ data: ${JSON.stringify(data)}
         {
           protocol: c.protocol,
           coverage: c.coverage,
-          ingress: c.targetName === "stripe" ? ingressSupport.stripe : ingressSupport.other,
+          ingress: supportsPublicIngress(c.targetName ?? "") ? ingressSupport[c.targetName] : ingressSupport.other,
           target: c.targetName,
           outboundPolicy: c.outboundPolicy ?? "unsupported",
           version: 1,
@@ -2332,11 +2388,12 @@ data: ${JSON.stringify(data)}
       format: "mockingbird.fleet/v1",
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       sourceId: this.ctx.id,
+      ...this.ctx.options.archiveCompatibility ? { compatibility: structuredClone(this.ctx.options.archiveCompatibility.tags) } : {},
       namespaces: contents
     });
   }
   async restoreArchive(input, selectedNamespace) {
-    const archive = validateArchive(input);
+    const archive = assertArchiveCompatibility(input, this.ctx.options.archiveCompatibility);
     const entries = Object.entries(archive.namespaces).filter(([ns]) => selectedNamespace === void 0 || ns === selectedNamespace);
     if (!entries.length)
       throw new Error("selected namespace absent from archive");
@@ -2621,6 +2678,9 @@ var fleet_config_schema_default = {
     adminControls: {
       $ref: "#/$defs/controls"
     },
+    idBase: {
+      $ref: "#/$defs/idBase"
+    },
     namespace: {
       type: "string",
       pattern: "^[A-Za-z0-9_.-]{1,64}$"
@@ -2710,6 +2770,12 @@ var fleet_config_schema_default = {
         adminControls: {
           $ref: "#/$defs/controls"
         },
+        idBase: {
+          $ref: "#/$defs/idBase"
+        },
+        settings: {
+          type: "object"
+        },
         fixtures: {
           type: "object"
         },
@@ -2756,6 +2822,18 @@ var fleet_config_schema_default = {
         }
       }
     },
+    idBase: {
+      anyOf: [
+        {
+          type: "integer",
+          minimum: 0
+        },
+        {
+          type: "string",
+          pattern: "^(boot|[0-9]+)$"
+        }
+      ]
+    },
     controls: {
       type: "object",
       additionalProperties: false,
@@ -2905,6 +2983,8 @@ async function preflightFleet(config, options) {
     throw new Error("protected archive policy requires a protected repository; configure its protector before startup");
   resolveAdminPrefix(config.adminPrefix);
   normalizeBootControls(config.adminControls);
+  if (config.idBase !== void 0)
+    normalizeIdBase(config.idBase, "idBase");
   const targets = /* @__PURE__ */ new Map();
   const ports = /* @__PURE__ */ new Set();
   for (const [name, entry] of Object.entries(config.services)) {
@@ -2920,7 +3000,7 @@ async function preflightFleet(config, options) {
       if (entry.target !== void 0 && !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(entry.target))
         throw new Error("target must name a supported service suffix");
       const service = entry.target ?? name;
-      if (advertisedHttpBase(entry) && service !== "stripe")
+      if (advertisedHttpBase(entry) && !supportsPublicIngress(service))
         throw new Error(`public ingress unsupported for ${service}; use a direct endpoint to preserve signed targets`);
       const target = await options.load(service);
       const protocol = "protocol" in target ? target.protocol : "http";
@@ -2936,6 +3016,13 @@ async function preflightFleet(config, options) {
             throw new Error("invalid protocol namespace selector");
         }
       }
+      if (entry.idBase !== void 0)
+        normalizeIdBase(entry.idBase, "idBase");
+      if (entry.settings !== void 0) {
+        if (protocol !== "http" || !("create" in target))
+          throw new Error("settings: only HTTP services take boot settings");
+        checkSettings(target, entry.settings, "settings");
+      }
       const port = entry.port ?? target.defaultPort;
       if (port !== 0) {
         const key = `${entry.host ?? "127.0.0.1"}:${port}`;
@@ -2971,7 +3058,7 @@ async function preflightFleet(config, options) {
             break;
         }
       }
-      targets.set(name, { ...target, packageVersion: packageVersion ?? "0.4.0" });
+      targets.set(name, { ...target, packageVersion: packageVersion ?? "0.6.0" });
     } catch (error) {
       throw new Error(`service ${name}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
     }
@@ -3015,6 +3102,11 @@ async function preflightFleet(config, options) {
   return ordered;
 }
 function validateFleetPolicies(options) {
+  if (options.archiveCompatibility) {
+    validateCompatibilityTags(options.archiveCompatibility.tags);
+    if (options.archiveCompatibility.missing !== void 0 && !["allow", "reject"].includes(options.archiveCompatibility.missing))
+      throw new Error("archiveCompatibility.missing must be allow or reject");
+  }
   if (options.journal && !options.repository)
     throw new Error("durable operation journal requires an archive repository");
   if (options.cors) {
@@ -3286,6 +3378,7 @@ var httpChild = async (target, entry, options, admission, generation, privateAcc
       options.onLog?.(entry2);
     },
     ...entry.adminControls !== void 0 ? { adminControls: entry.adminControls } : {},
+    ...entry.settings !== void 0 ? { settings: checkSettings(target, entry.settings, "settings") } : {},
     ...entry.fixtures !== void 0 ? { fixtures: entry.fixtures } : {},
     ...(advertisedHttpBase(entry) ?? entry.baseUrl) !== void 0 ? { baseUrl: advertisedHttpBase(entry) ?? entry.baseUrl } : {}
   });
@@ -3304,6 +3397,8 @@ var httpChild = async (target, entry, options, admission, generation, privateAcc
   ].some((method) => typeof created[method] !== "function"))
     throw new Error("HTTP target does not implement the fleet runtime protocol; build/install matching supported service versions");
   const runtime = created;
+  if (entry.idBase !== void 0)
+    runtime.setIdBase?.(entry.idBase);
   const unobserve = runtime.webhooks?.observeDeliveries(observer.delivery);
   if (options.outbound && runtime.webhooks)
     runtime.webhooks.setTransportPolicy(ownedTransport(options.outbound));
@@ -3902,6 +3997,7 @@ async function startFleet(config, options) {
           ...entry,
           adminPrefix: resolveAdminPrefix(entry.adminPrefix ?? adminPrefix),
           ...adminKey !== void 0 ? { adminKey } : {},
+          ...(entry.idBase ?? config.idBase) !== void 0 ? { idBase: entry.idBase ?? config.idBase } : {},
           // Fleet-wide controls, with the service's own keys replacing them.
           ...config.adminControls !== void 0 || entry.adminControls !== void 0 ? { adminControls: { ...config.adminControls, ...entry.adminControls } } : {}
         }, options, (namespace, request) => management?.admit(namespace, request), (namespace) => management?.generation(namespace), (namespace, request) => management?.privateRequest(namespace, request) ?? false, {
@@ -4007,10 +4103,44 @@ async function startFleet(config, options) {
   }
 }
 
-// ../../adapters/node/dist/fleet-tools.js
-import { readFile as readFile4 } from "node:fs/promises";
+// ../../adapters/node/dist/fleet-loader.js
 import { createRequire as createRequire2 } from "node:module";
 import { resolve as resolve2 } from "node:path";
+import { pathToFileURL } from "node:url";
+var suffix = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function createInstalledServiceLoader(options) {
+  if (!options.projectRoot)
+    throw new Error("consumer projectRoot required");
+  const allowed = new Set(options.services);
+  for (const name of allowed)
+    if (!suffix.test(name))
+      throw new Error("invalid service suffix");
+  const require2 = createRequire2(resolve2(options.projectRoot, "package.json"));
+  const targets = new Map((options.targets ?? []).map((target) => [target.name, target]));
+  return async (name) => {
+    if (!suffix.test(name) || !allowed.has(name))
+      throw new Error("service is not declared in loader allowlist");
+    const own = targets.get(name);
+    if (own)
+      return own;
+    const specifier = `@crvouga/mockingbird-service-${name}/server`;
+    let location;
+    try {
+      location = require2.resolve(specifier);
+    } catch {
+      throw new Error(`cannot load service "${name}": install @crvouga/mockingbird-service-${name} in the consumer project; its /server export is required`);
+    }
+    const mod = await import(pathToFileURL(location).href);
+    if (!mod.serveTarget || mod.serveTarget.name !== name || ("protocol" in mod.serveTarget ? typeof mod.serveTarget.start !== "function" : typeof mod.serveTarget.create !== "function"))
+      throw new Error(`${specifier} exports no matching serveTarget`);
+    return mod.serveTarget;
+  };
+}
+
+// ../../adapters/node/dist/fleet-tools.js
+import { readFile as readFile4 } from "node:fs/promises";
+import { createRequire as createRequire3 } from "node:module";
+import { resolve as resolve3 } from "node:path";
 
 // ../../adapters/node/dist/fleet-client.js
 import { randomUUID as randomUUID5 } from "node:crypto";
@@ -4024,6 +4154,14 @@ var FleetClientError = class extends Error {
     this.details = details;
   }
 };
+var FleetClientResponseError = class extends FleetClientError {
+  code;
+  constructor(code, status, origin) {
+    super(status, { code, body: "omitted", ...origin ? { origin } : {} });
+    this.code = code;
+    this.name = "FleetClientResponseError";
+  }
+};
 var FleetClient = class {
   base;
   options;
@@ -4036,7 +4174,14 @@ var FleetClient = class {
     if (url.username || url.password)
       throw new Error("fleet client URL must not contain credentials");
     url.searchParams.set("namespace", options.namespace ?? this.options.namespace ?? "default");
+    const limit = options.maxResponseBytes ?? this.options.maxResponseBytes ?? 64 * 1024 * 1024;
+    if (!Number.isSafeInteger(limit) || limit < 1)
+      throw new Error("invalid response byte limit");
+    const deadline = AbortSignal.timeout(this.options.timeoutMs ?? 3e4);
+    const signal = options.signal ? AbortSignal.any([options.signal, deadline]) : deadline;
+    signal.throwIfAborted();
     const response = await (this.options.fetch ?? fetch)(url, {
+      redirect: "manual",
       method: options.method ?? (options.body === void 0 ? "GET" : "POST"),
       headers: {
         "content-type": "application/json",
@@ -4044,11 +4189,71 @@ var FleetClient = class {
         ...options.idempotencyKey ? { "idempotency-key": options.idempotencyKey } : {}
       },
       ...options.body !== void 0 ? { body: JSON.stringify(options.body) } : {},
-      signal: options.signal ?? AbortSignal.timeout(this.options.timeoutMs ?? 3e4)
+      signal
     });
-    const data = await response.json();
-    if (!response.ok)
-      throw new FleetClientError(response.status, data);
+    if (response.status >= 300 && response.status < 400) {
+      await response.body?.cancel();
+      throw new FleetClientResponseError("redirect", response.status, url.origin);
+    }
+    if (Number(response.headers.get("content-length")) > limit) {
+      await response.body?.cancel();
+      throw new FleetClientResponseError("response_too_large", response.status);
+    }
+    const reader = response.body?.getReader();
+    const chunks = [];
+    let size = 0;
+    const abort = () => {
+      void reader?.cancel(signal.reason).catch(() => {
+      });
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    try {
+      if (reader)
+        while (true) {
+          signal.throwIfAborted();
+          const { done, value } = await reader.read();
+          signal.throwIfAborted();
+          if (done)
+            break;
+          size += value.byteLength;
+          if (size > limit) {
+            await reader.cancel();
+            throw new FleetClientResponseError("response_too_large", response.status);
+          }
+          chunks.push(value);
+        }
+    } finally {
+      signal.removeEventListener("abort", abort);
+      if (signal.aborted)
+        await reader?.cancel(signal.reason).catch(() => {
+        });
+      reader?.releaseLock();
+    }
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+      bytes.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    const text2 = new TextDecoder().decode(bytes);
+    let data;
+    try {
+      data = text2.length ? JSON.parse(text2) : void 0;
+    } catch {
+      if (response.ok)
+        throw new FleetClientResponseError("invalid_json", response.status);
+    }
+    if (!response.ok) {
+      const error = data && typeof data === "object" ? data.error : void 0;
+      const detail = { body: "omitted" };
+      if (error && typeof error === "object")
+        for (const key of ["type", "code"]) {
+          const value = error[key];
+          if (typeof value === "string" && /^[A-Za-z0-9_.-]{1,128}$/.test(value))
+            detail[key] = value;
+        }
+      throw new FleetClientError(response.status, detail);
+    }
     return data;
   }
   discover() {
@@ -4114,17 +4319,52 @@ function renderConnections(manifest, privateManifest, namespace, mapping) {
     const child = manifest.services[entry.service], secret = privateManifest.services[entry.service];
     if (!child || !secret)
       throw new Error(`missing service mapping ${entry.service}`);
+    let endpoint;
     if (child.protocol === "http") {
       const template = child.namespaces.path;
       if (typeof template !== "string")
         throw new Error(`missing HTTP namespace mapping ${entry.service}`);
-      result[variable] = new URL(template.replace("{name}", encodeURIComponent(namespace)), secret.url).href;
+      endpoint = new URL(template.replace("{name}", encodeURIComponent(namespace)), secret.url).href;
     } else {
-      const endpoint = secret.namespaces?.[namespace];
-      if (!endpoint)
+      const selected = secret.namespaces?.[namespace];
+      if (!selected)
         throw new Error(`missing namespace mapping ${namespace}/${entry.service}`);
-      result[variable] = endpoint;
+      endpoint = selected;
+    }
+    const url = new URL(endpoint);
+    const field = entry.field ?? "url";
+    let value;
+    switch (field) {
+      case "url":
+        value = endpoint;
+        break;
+      case "hostname":
+        value = url.hostname.replace(/^\[|\]$/g, "");
+        break;
+      case "port":
+        value = url.port;
+        break;
+      case "username":
+        value = decodeURIComponent(url.username);
+        break;
+      case "password":
+        value = decodeURIComponent(url.password);
+        break;
+      case "pathname":
+        value = decodeURIComponent(url.pathname);
+        break;
+      case "database":
+        value = decodeURIComponent(url.pathname.replace(/^\//, ""));
+        break;
+      default:
+        throw new Error("unsupported connection field");
     }
+    if (!value) {
+      if (typeof entry.fallback !== "string")
+        throw new Error(`missing connection component ${field}`);
+      value = entry.fallback;
+    }
+    result[variable] = value;
   }
   return result;
 }
@@ -4148,7 +4388,7 @@ async function doctorFleet(config, options, probes = []) {
   const plan = [];
   try {
     const targets = await preflightFleet(config, options);
-    const require2 = createRequire2(resolve2(process.cwd(), "package.json"));
+    const require2 = createRequire3(resolve3(process.cwd(), "package.json"));
     for (const [service, target] of targets) {
       let version = "development";
       try {
@@ -4203,7 +4443,7 @@ async function doctorFleet(config, options, probes = []) {
   };
 }
 async function rehearseFleet(config, options, input, probes = [], timeoutMs = 3e4) {
-  const archive = validateArchive(input);
+  const archive = assertArchiveCompatibility(input, options.archiveCompatibility);
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   const isolated = {
     ...config,
@@ -4215,7 +4455,7 @@ async function rehearseFleet(config, options, input, probes = [], timeoutMs = 3e
   };
   let fleet;
   try {
-    fleet = await startFleet(isolated, { load: options.load });
+    fleet = await startFleet(isolated, options);
     const client = new FleetClient(fleet.manifest.adminBase, {
       ...config.adminKey ? { adminKey: config.adminKey } : {}
     });
@@ -4442,6 +4682,16 @@ var COMMON_SERVE_OPTIONS = {
     value: "<seed>",
     description: "Seed for every random choice (env MOCKINGBIRD_SEED)"
   },
+  "id-base": {
+    type: "string",
+    value: "<n|boot>",
+    description: "Start generated ids at this base so a restart does not reissue the last boot's ids; boot derives one from the clock (env MOCKINGBIRD_ID_BASE; default 0, the same ids every boot)"
+  },
+  settings: {
+    type: "string",
+    value: "<json|file>",
+    description: "Service settings to boot with, as JSON or a JSON file; every namespace starts from them (env MOCKINGBIRD_SETTINGS; only for services that declare settings)"
+  },
   "admin-controls": {
     type: "string",
     value: "<json|file>",
@@ -4536,19 +4786,40 @@ var readJsonFile = async (path, label) => {
   }
 };
 var isObject2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var readJsonOption = async (source, label) => {
+  const trimmed = source.trim();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      throw new Error(`${label}: not valid JSON`);
+    }
+  }
+  return readJsonFile(source, label);
+};
+var resolveServeIdBase = (values, env = process.env) => {
+  const source = asString(values["id-base"]) ?? env.MOCKINGBIRD_ID_BASE;
+  if (source === void 0 || source.trim() === "")
+    return void 0;
+  normalizeIdBase(source.trim(), "--id-base");
+  return source.trim();
+};
+var resolveServeSettings = async (target, values, env = process.env) => {
+  const flag = asString(values.settings);
+  const source = flag ?? env.MOCKINGBIRD_SETTINGS;
+  if (source === void 0 || source.trim() === "")
+    return void 0;
+  const label = flag !== void 0 ? "--settings" : "MOCKINGBIRD_SETTINGS";
+  const parsed = await readJsonOption(source, label);
+  if (!isObject2(parsed))
+    throw new Error(`${label}: expected a JSON object`);
+  return checkSettings(target, parsed, label);
+};
 var resolveServeControls = async (values, env = process.env, base) => {
   const source = asString(values["admin-controls"]) ?? env.MOCKINGBIRD_ADMIN_CONTROLS;
   let document = isObject2(base) ? { ...base } : {};
   if (source !== void 0 && source.trim() !== "") {
-    let parsed;
-    if (source.trim().startsWith("{")) {
-      try {
-        parsed = JSON.parse(source);
-      } catch {
-        throw new Error("--admin-controls: not valid JSON");
-      }
-    } else
-      parsed = await readJsonFile(source, "--admin-controls");
+    const parsed = source.trim().startsWith("{") ? await readJsonOption(source, "--admin-controls") : await readJsonFile(source, "--admin-controls");
     if (!isObject2(parsed))
       throw new Error("--admin-controls: expected a JSON object");
     document = { ...document, ...parsed };
@@ -4590,26 +4861,7 @@ var resolveServeControls = async (values, env = process.env, base) => {
   normalizeBootControls(document, "adminControls");
   return document;
 };
-var loadTarget = async (name, own) => {
-  if (name === own.name)
-    return own;
-  const specifier = `@crvouga/mockingbird-service-${name}/server`;
-  try {
-    let mod;
-    try {
-      mod = await import(specifier);
-    } catch {
-      const fromProject = createRequire3(resolve3(process.cwd(), "package.json"));
-      mod = await import(pathToFileURL(fromProject.resolve(specifier)).href);
-    }
-    if (!mod.serveTarget)
-      throw new Error(`${specifier} exports no serveTarget`);
-    return mod.serveTarget;
-  } catch (error) {
-    const reason = error instanceof Error ? error.message : String(error);
-    throw new Error(`cannot load service "${name}": ${reason}. Install @crvouga/mockingbird-service-${name}.`);
-  }
-};
+var loadTarget = (name, own) => createInstalledServiceLoader({ projectRoot: process.cwd(), services: [name], targets: [own] })(name);
 var start = async (target, values, config) => {
   const adminPrefix = resolveAdminPrefix(config.adminPrefix);
   const runtime = await target.create(values, {
@@ -4617,8 +4869,11 @@ var start = async (target, values, config) => {
     adminKey: config.adminKey,
     seed: config.seed,
     onLog: formatLog(config.log),
+    ...config.settings !== void 0 ? { settings: config.settings } : {},
     ...config.adminControls !== void 0 ? { adminControls: config.adminControls } : {}
   });
+  if (config.idBase !== void 0)
+    runtime.setIdBase?.(config.idBase);
   const listening = await listen(runtime, { port: config.port, host: config.host });
   target.listening?.(listening);
   console.log(`${target.name} emulator listening on ${listening.url}`);
@@ -4664,6 +4919,11 @@ var serveCommand = (target) => ({
         const adminControls = await resolveServeControls(values, process.env, config.adminControls);
         if (adminControls !== void 0)
           config.adminControls = adminControls;
+        if (values.settings !== void 0)
+          throw new Error("--settings serves a single service; give each service its own `settings` in the config");
+        const idBase = config.idBase ?? resolveServeIdBase(values);
+        if (idBase !== void 0)
+          config.idBase = idBase;
         const fleet = await startFleet(config, {
           load: (name) => loadTarget(name, target),
           onLog: formatLog(config.log ?? log),
@@ -4693,8 +4953,12 @@ var serveCommand = (target) => ({
     let listening;
     try {
       const adminControls = await resolveServeControls(values);
+      const idBase = resolveServeIdBase(values);
+      const settings = await resolveServeSettings(target, values);
       listening = await start(target, values, {
         ...adminControls !== void 0 ? { adminControls } : {},
+        ...idBase !== void 0 ? { idBase } : {},
+        ...settings !== void 0 ? { settings } : {},
         adminPrefix: resolveAdminPrefix(asString(values["admin-prefix"]) ?? process.env.MOCKINGBIRD_ADMIN_PREFIX),
         port: port === void 0 ? target.defaultPort : Number.parseInt(port, 10),
         host: asString(values.host) ?? "127.0.0.1",
@@ -5131,4 +5395,4 @@ export {
   connectStream,
   serveTarget
 };
-//# sourceMappingURL=chunk-F6A6NHJ6.js.map
+//# sourceMappingURL=chunk-NB5GDNQB.js.map