stitchkit 0.76.2 → 0.78.0

package/dist/{index-58jzmnn4.js → index-k45qqrdh.js}

@@ -1,19 +1,71 @@
-import {
-  DEFAULT_STREAM_LINE_BYTES,
-  inputIsQuery,
-  parseSSE,
-  readBoundedUtf8Lines
-} from "./index-1rxswfbv.js";
 import {
   ContractStreamFrameSchema,
   DEFAULT_CONTRACT_STREAM_FRAME_BYTES,
   parseTrailingWildcard
-} from "./index-vj3vvpaa.js";
+} from "./index-7z69kyrh.js";
 import {
   isRecord,
   mapObject,
+  transportResult,
   typedEntries
-} from "./index-qyrqwr4c.js";
+} from "./index-ksp6e2ye.js";
+
+// src/internal/random-hex.ts
+function randomHex(bytes) {
+  const arr = new Uint8Array(bytes);
+  crypto.getRandomValues(arr);
+  let hex = "";
+  for (const byte of arr)
+    hex += byte.toString(16).padStart(2, "0");
+  return hex;
+}
+
+// src/observability/trace.ts
+var TRACEPARENT_RE = /^([0-9a-f]{2})-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})(.*)$/i;
+function createTraceContext() {
+  return { traceId: randomHex(16), spanId: randomHex(8) };
+}
+function parseTraceparent(header) {
+  if (!header)
+    return null;
+  const match = TRACEPARENT_RE.exec(header.trim());
+  if (!match?.[1] || !match[2] || !match[3] || !match[4] || match[5] === undefined)
+    return null;
+  const version = match[1].toLowerCase();
+  if (version === "ff")
+    return null;
+  const suffix = match[5];
+  if (version === "00" ? suffix !== "" : suffix !== "" && !/^(?:-[0-9a-f]{2,})+$/i.test(suffix)) {
+    return null;
+  }
+  const traceId = match[2].toLowerCase();
+  const parentSpanId = match[3].toLowerCase();
+  const traceFlags = match[4].toLowerCase();
+  if (/^0+$/.test(traceId) || /^0+$/.test(parentSpanId))
+    return null;
+  return { traceId, spanId: randomHex(8), parentSpanId, traceFlags };
+}
+function formatTraceparent(ctx) {
+  return `00-${ctx.traceId}-${ctx.spanId}-${ctx.traceFlags ?? "01"}`;
+}
+function childSpan(parent) {
+  return {
+    traceId: parent.traceId,
+    spanId: randomHex(8),
+    parentSpanId: parent.spanId,
+    ...parent.tracestate !== undefined && { tracestate: parent.tracestate },
+    ...parent.baggage !== undefined && { baggage: parent.baggage },
+    ...parent.traceFlags !== undefined && { traceFlags: parent.traceFlags }
+  };
+}
+var encoder = new TextEncoder;
+
+// src/browser/http.ts
+import ky, {
+  isHTTPError,
+  isNetworkError,
+  isTimeoutError
+} from "ky";
 
 // src/browser/cancellation.ts
 class RequestCancellationError extends Error {
@@ -72,13 +124,6 @@ function cancellationError(cause) {
   return new RequestCancellationError(cause);
 }
 
-// src/browser/http.ts
-import ky, {
-  isHTTPError,
-  isNetworkError,
-  isTimeoutError
-} from "ky";
-
 // src/browser/request-id.ts
 var REQUEST_ID_HEADER = "x-request-id";
 function responseTraceId(response) {
@@ -114,6 +159,15 @@ class ApiError extends Error {
 function refuseLocally(path, message) {
   return new ApiError("VALIDATION_ERROR", 0, { issues: [{ path, code: "invalid_type", message }] }, message);
 }
+function shouldRetryBunNetworkError(error) {
+  if (ApiError.is(error) || isHTTPError(error) || isNetworkError(error) || isTimeoutError(error) || error instanceof RequestCancellationError || error instanceof DOMException && (error.name === "AbortError" || error.name === "TimeoutError")) {
+    return;
+  }
+  if (!(error instanceof Error))
+    return;
+  const code = Object.getOwnPropertyDescriptor(error, "code");
+  return code && "value" in code && code.value === "ConnectionRefused" ? true : undefined;
+}
 function parseApiErrorBody(body) {
   if (!isRecord(body) || !isRecord(body.error))
     return null;
@@ -127,6 +181,329 @@ function parseApiErrorBody(body) {
     hint: typeof error.hint === "string" ? error.hint : undefined
   };
 }
+function createRetryAwareFetch(transportFetch, unix) {
+  const runtimeFetch = transportFetch;
+  let attempt = 0;
+  return (input, init) => {
+    attempt += 1;
+    if (unix === undefined && attempt === 1) {
+      return runtimeFetch(input, init);
+    }
+    if (!(input instanceof Request)) {
+      if (unix === undefined)
+        return runtimeFetch(input, init);
+      const unixInit = { ...init, unix };
+      return runtimeFetch(input, unixInit);
+    }
+    const streamedBody = input.body ? { body: input.body, duplex: "half" } : {};
+    const materialized = {
+      ...init,
+      ...unix !== undefined && { unix },
+      method: input.method,
+      headers: input.headers,
+      ...streamedBody,
+      cache: input.cache,
+      credentials: input.credentials,
+      integrity: input.integrity,
+      keepalive: input.keepalive,
+      mode: input.mode,
+      redirect: input.redirect,
+      referrer: input.referrer,
+      referrerPolicy: input.referrerPolicy,
+      signal: input.signal
+    };
+    return runtimeFetch(input.url, materialized);
+  };
+}
+function createHttpClient(config) {
+  if (config.fetch && config.unix) {
+    throw new TypeError("HttpClientConfig.fetch and unix are mutually exclusive");
+  }
+  if (config.unix !== undefined) {
+    if (!config.unix.startsWith("/") || config.unix.includes("\x00")) {
+      throw new TypeError("HttpClientConfig.unix must be an absolute Unix socket path");
+    }
+    if (typeof Reflect.get(globalThis, "Bun") !== "object") {
+      throw new TypeError("HttpClientConfig.unix requires Bun; on Bun or Node use createUnixClientTransport().fetch for an explicit portable transport");
+    }
+  }
+  let ssrCookies = null;
+  let isLoggedOut = false;
+  const listeners = new Set;
+  const suppressUnauthorizedFor = config.suppressUnauthorizedFor ?? [];
+  const parseError = config.parseError ?? parseApiErrorBody;
+  function emit(event) {
+    for (const fn of listeners) {
+      try {
+        fn(event);
+      } catch {}
+    }
+  }
+  const client = ky.create({
+    prefix: config.baseUrl,
+    credentials: config.credentials ?? "include",
+    timeout: false,
+    retry: {
+      limit: config.retry?.limit ?? 2,
+      methods: config.retry?.methods ?? ["get"],
+      statusCodes: config.retry?.statusCodes ?? [],
+      shouldRetry: ({ error }) => shouldRetryBunNetworkError(error)
+    },
+    hooks: {
+      beforeRequest: [
+        ({ request: request2 }) => {
+          if (ssrCookies) {
+            request2.headers.set("Cookie", ssrCookies);
+          }
+          const extra = typeof config.headers === "function" ? config.headers() : config.headers;
+          if (extra) {
+            for (const [key, value] of Object.entries(extra)) {
+              request2.headers.set(key, value);
+            }
+          }
+          if (config.trace && !request2.headers.has("traceparent")) {
+            request2.headers.set("traceparent", formatTraceparent(createTraceContext()));
+          }
+        }
+      ],
+      afterResponse: [
+        async ({ request: request2, response }) => {
+          if (response.status === 401) {
+            const url = new URL(request2.url).pathname;
+            if (!isLoggedOut && !suppressUnauthorizedFor.some((matches) => matches(url))) {
+              isLoggedOut = true;
+              emit({ type: "unauthorized" });
+            }
+          }
+          if (!response.ok) {
+            const body = await response.clone().json().catch(() => null);
+            if (body) {
+              const parsed = parseError(body);
+              if (parsed) {
+                throw new ApiError(parsed.code, response.status, parsed.details, parsed.message, parsed.hint, responseTraceId(response));
+              }
+            }
+          }
+        }
+      ]
+    }
+  });
+  async function request(method, url, data, options = {}) {
+    const cancellation = createRequestCancellation(options.signal, options.timeout ?? config.timeout ?? 30000);
+    const kyOptions = {
+      fetch: createRetryAwareFetch(config.fetch ?? globalThis.fetch.bind(globalThis), config.unix),
+      timeout: false,
+      signal: cancellation.signal
+    };
+    if (options.params) {
+      const searchParams = new URLSearchParams;
+      for (const [key, value] of Object.entries(options.params)) {
+        if (value === undefined)
+          continue;
+        if (Array.isArray(value)) {
+          for (const item of value)
+            searchParams.append(key, String(item));
+        } else {
+          searchParams.set(key, String(value));
+        }
+      }
+      if (searchParams.size > 0) {
+        kyOptions.searchParams = searchParams;
+      }
+    }
+    if (data instanceof FormData) {
+      kyOptions.body = data;
+    } else if (data !== undefined) {
+      kyOptions.json = data;
+    }
+    try {
+      return await cancellation.run(async () => {
+        if (options.responseType === "blob") {
+          return transportResult(await client[method](url, kyOptions).blob());
+        }
+        if (options.responseType === "response") {
+          return transportResult(await client[method](url, kyOptions));
+        }
+        const response = await client[method](url, kyOptions);
+        if (options.responseType === "void") {
+          const text = await response.text();
+          if (text.length > 0) {
+            throw new Error("Server returned data for an endpoint with no output contract");
+          }
+        }
+        if (options.responseType === "void" || response.status === 204 || response.headers.get("content-length") === "0") {
+          return transportResult(undefined);
+        }
+        return await response.json();
+      });
+    } catch (error) {
+      if (error instanceof RequestCancellationError) {
+        throw new ApiError(error.cause === "caller" ? "REQUEST_ABORTED" : "REQUEST_TIMEOUT", 0, undefined, error.message);
+      }
+      if (ApiError.is(error))
+        throw error;
+      emit({ type: "network_error" });
+      const response = isHTTPError(error) ? error.response : undefined;
+      const status = response?.status ?? 0;
+      const msg = error instanceof Error ? error.message : undefined;
+      throw new ApiError("UNKNOWN_ERROR", status, msg ? { message: msg } : undefined, msg, undefined, responseTraceId(response), { cause: error });
+    }
+  }
+  return {
+    baseUrl: config.baseUrl,
+    get: (url, options) => request("get", url, undefined, options),
+    head: (url, options) => request("head", url, undefined, options),
+    post: (url, data, options) => request("post", url, data, options),
+    put: (url, data, options) => request("put", url, data, options),
+    patch: (url, data, options) => request("patch", url, data, options),
+    delete: (url, options) => request("delete", url, undefined, options),
+    setServerContext(cookies) {
+      ssrCookies = cookies;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    logout() {
+      isLoggedOut = true;
+      emit({ type: "logout" });
+    },
+    resetLogoutState() {
+      isLoggedOut = false;
+    }
+  };
+}
+
+// src/internal/errors.ts
+import { z } from "zod";
+function issuePath(path) {
+  return path.length > 0 ? path.map(String).join(".") : "(root)";
+}
+function formatZodError(error) {
+  const issues = error.issues.slice(0, 5);
+  const lines = issues.map((issue) => `${issuePath(issue.path)}: ${issue.message}`);
+  const suffix = error.issues.length > 5 ? `
+...and ${error.issues.length - 5} more issues` : "";
+  return lines.join(`
+`) + suffix;
+}
+function zodIssues(error) {
+  return error.issues.map((issue) => ({
+    path: issuePath(issue.path),
+    code: issue.code,
+    message: issue.message
+  }));
+}
+
+// src/internal/bounded-lines.ts
+var DEFAULT_STREAM_LINE_BYTES = 1024 * 1024;
+function lineLimit(value) {
+  const resolved = value ?? DEFAULT_STREAM_LINE_BYTES;
+  if (!Number.isSafeInteger(resolved) || resolved <= 0) {
+    throw new TypeError("maxLineBytes must be a positive safe integer");
+  }
+  return resolved;
+}
+function joinBytes(left, right) {
+  if (left.byteLength === 0)
+    return right.slice();
+  const result = new Uint8Array(left.byteLength + right.byteLength);
+  result.set(left);
+  result.set(right, left.byteLength);
+  return result;
+}
+async function* readBoundedUtf8Lines(response, maxLineBytes, requireFinalNewline = false) {
+  const reader = response.body?.getReader();
+  if (!reader)
+    return;
+  const limit = lineLimit(maxLineBytes);
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  let pending = new Uint8Array;
+  try {
+    for (;; ) {
+      const chunk = await reader.read();
+      if (chunk.done)
+        break;
+      let start = 0;
+      for (let index = 0;index < chunk.value.byteLength; index += 1) {
+        if (chunk.value[index] !== 10)
+          continue;
+        const lineBytes = joinBytes(pending, chunk.value.slice(start, index));
+        if (lineBytes.byteLength > limit) {
+          throw new RangeError(`Stream line exceeds the ${limit} byte limit`);
+        }
+        yield decoder.decode(lineBytes);
+        pending = new Uint8Array;
+        start = index + 1;
+      }
+      pending = joinBytes(pending, chunk.value.slice(start));
+      if (pending.byteLength > limit) {
+        throw new RangeError(`Stream line exceeds the ${limit} byte limit`);
+      }
+    }
+    if (pending.byteLength > 0) {
+      if (requireFinalNewline) {
+        throw new SyntaxError("Stream ended with an unterminated final line");
+      }
+      yield decoder.decode(pending);
+    }
+  } finally {
+    await reader.cancel().catch(() => {
+      return;
+    });
+    reader.releaseLock();
+  }
+}
+
+// src/server/stream.ts
+async function* parseSSE(response, options) {
+  try {
+    for await (const rawLine of readBoundedUtf8Lines(response, options?.maxLineBytes ?? DEFAULT_STREAM_LINE_BYTES)) {
+      const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+      if (!line.startsWith("data:"))
+        continue;
+      const data = line.slice(5).replace(/^ /, "");
+      if (data === "[DONE]")
+        return;
+      try {
+        yield JSON.parse(data);
+      } catch (error) {
+        const failure = error instanceof Error ? error : new Error(String(error));
+        if (!options?.onParseError)
+          throw failure;
+        options.onParseError(data, failure);
+      }
+    }
+  } catch (error) {
+    const failure = error instanceof Error ? error : new Error(String(error));
+    if (!options?.onParseError)
+      throw failure;
+    options.onParseError("", failure);
+  }
+}
+// src/browser/stream.ts
+function parseFailure(raw, error, onParseError) {
+  const failure = error instanceof Error ? error : new Error(String(error));
+  if (!onParseError)
+    throw failure;
+  onParseError(raw, failure);
+}
+async function* parseNDJSON(response, options) {
+  try {
+    for await (const rawLine of readBoundedUtf8Lines(response, options?.maxLineBytes ?? DEFAULT_STREAM_LINE_BYTES, options?.finalLine === "require-newline")) {
+      const line = (rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine).trim();
+      if (line === "")
+        continue;
+      try {
+        yield JSON.parse(line);
+      } catch (error) {
+        parseFailure(line, error, options?.onParseError);
+      }
+    }
+  } catch (error) {
+    parseFailure("", error, options?.onParseError);
+  }
+}
 
 // src/browser/client-multipart.ts
 function isFileDescriptor(value) {
@@ -178,6 +555,11 @@ function buildMultipartForm(descriptor, values) {
   return formData;
 }
 
+// src/internal/http-input.ts
+function inputIsQuery(method) {
+  return method === "GET" || method === "DELETE";
+}
+
 // src/browser/client-url.ts
 function isParamArray(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "string" || typeof item === "number");
@@ -217,6 +599,52 @@ function resolvePathPrefix(config, args) {
   }
   return config.pathPrefix(args);
 }
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function decodePathSegment(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function createClientRouteMatcher(endpoint, contractPrefix, config) {
+  if (typeof config?.pathPrefix === "function" && (!config.stripPrefixKeys || config.stripPrefixKeys.length === 0)) {
+    throw new Error("Dynamic pathPrefix matchers require stripPrefixKeys");
+  }
+  const markerByKey = {};
+  for (const [index, key] of (config?.stripPrefixKeys ?? []).entries()) {
+    markerByKey[key] = `__stitch_scope_${index}__`;
+  }
+  const pathPrefix = resolvePathPrefix(config, markerByKey);
+  const route = [pathPrefix, contractPrefix, endpoint.path === "/" ? "" : endpoint.path].filter(Boolean).join("/");
+  const patternSegments = route.split("/").filter(Boolean);
+  const wildcard = patternSegments.at(-1)?.startsWith("*") === true;
+  const fixedCount = wildcard ? patternSegments.length - 1 : patternSegments.length;
+  const markers = Object.values(markerByKey);
+  return (pathname) => {
+    const actualSegments = pathname.split("/").filter(Boolean).map(decodePathSegment);
+    if (wildcard ? actualSegments.length < fixedCount : actualSegments.length !== fixedCount) {
+      return false;
+    }
+    for (let index = 0;index < fixedCount; index += 1) {
+      const pattern = patternSegments[index];
+      const actual = actualSegments[index];
+      if (!pattern || actual === undefined)
+        return false;
+      if (pattern.startsWith(":"))
+        continue;
+      let source = escapeRegex(pattern);
+      for (const marker of markers) {
+        source = source.replaceAll(escapeRegex(marker), "[^/]+");
+      }
+      if (!new RegExp(`^${source}$`).test(actual))
+        return false;
+    }
+    return true;
+  };
+}
 function extractParamNames(path) {
   const matches = path.match(/:(\w+)/g);
   const names = matches ? matches.map((match) => match.slice(1)) : [];
@@ -290,29 +718,6 @@ function joinClientBaseUrl(baseUrl, relativeUrl) {
   const path = relativeUrl.startsWith("/") ? relativeUrl : `/${relativeUrl}`;
   return `${base}${path}`;
 }
-// src/browser/stream.ts
-function parseFailure(raw, error, onParseError) {
-  const failure = error instanceof Error ? error : new Error(String(error));
-  if (!onParseError)
-    throw failure;
-  onParseError(raw, failure);
-}
-async function* parseNDJSON(response, options) {
-  try {
-    for await (const rawLine of readBoundedUtf8Lines(response, options?.maxLineBytes ?? DEFAULT_STREAM_LINE_BYTES, options?.finalLine === "require-newline")) {
-      const line = (rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine).trim();
-      if (line === "")
-        continue;
-      try {
-        yield JSON.parse(line);
-      } catch (error) {
-        parseFailure(line, error, options?.onParseError);
-      }
-    }
-  } catch (error) {
-    parseFailure("", error, options?.onParseError);
-  }
-}
 
 // src/browser/contract-stream.ts
 function sourceFor(response, descriptor) {
@@ -448,6 +853,25 @@ function withOutput(endpoint, result, abortStream) {
     return schema.parse(value);
   });
 }
+function contractEndpointMatchers(contract, endpointNames, contractConfig) {
+  const selected = endpointNames ? new Set(endpointNames) : null;
+  const matchers = [];
+  for (const [key, endpoint] of typedEntries(contract.endpoints)) {
+    if (selected && !selected.has(key))
+      continue;
+    if (endpoint.expose && !endpoint.expose.includes("HTTP")) {
+      if (selected) {
+        throw new Error(`Cannot create an HTTP route matcher for non-HTTP endpoint: ${String(key)}`);
+      }
+      continue;
+    }
+    matchers.push(createClientRouteMatcher(endpoint, contract.meta.prefix, contractConfig));
+  }
+  if (selected && matchers.length !== selected.size) {
+    throw new Error("Cannot create an HTTP route matcher for an unknown endpoint");
+  }
+  return matchers;
+}
 function createClient(contract, configOrClient, contractConfig) {
   const client = {};
   const makeExecutor = isHttpAdapter(configOrClient) ? (endpoint) => createHttpExecutor(endpoint, contract.meta.prefix, configOrClient, contractConfig) : (endpoint) => createFetchExecutor(endpoint, contract.meta.prefix, configOrClient, contractConfig);
@@ -461,6 +885,34 @@ function createClient(contract, configOrClient, contractConfig) {
 function createClients(contracts, configOrClient, contractConfig) {
   return mapObject(contracts, (_key, contract) => createClient(contract, configOrClient, contractConfig));
 }
+function buildScopedRegistry(contracts, scopeConfigs, surfaceName, build) {
+  const registry = {};
+  for (const [namespace, value] of Object.entries(contracts)) {
+    const list = Array.isArray(value) ? value : [value];
+    const surface = {};
+    for (const contract of list) {
+      const scope = contract.meta.scope;
+      if (!scope) {
+        throw new Error(`Contract in ${surfaceName} namespace "${namespace}" has no scope`);
+      }
+      const scopeConfig = scopeConfigs[scope];
+      if (!scopeConfig) {
+        throw new Error(`Missing ${surfaceName} config for scope: ${scope}`);
+      }
+      for (const [methodName, method] of Object.entries(build(contract, scopeConfig))) {
+        if (Object.hasOwn(surface, methodName)) {
+          throw new Error(`${surfaceName[0]?.toUpperCase()}${surfaceName.slice(1)} namespace "${namespace}" has duplicate method: ${methodName}`);
+        }
+        surface[methodName] = method;
+      }
+    }
+    registry[namespace] = surface;
+  }
+  return registry;
+}
+function createScopedClients(contracts, configOrClient, scopeConfigs) {
+  return buildScopedRegistry(contracts, scopeConfigs, "client", (contract, config) => createClient(contract, configOrClient, config));
+}
 function isHttpAdapter(value) {
   return typeof value === "object" && "get" in value && typeof value.get === "function";
 }
@@ -633,5 +1085,27 @@ async function throwForErrorResponse(res, config, fallbackBody) {
   }
   throw new ApiError("HTTP_ERROR", res.status, { body }, undefined, undefined, responseTraceId(res));
 }
+function createUrlBuilder(contract, source, contractConfig) {
+  const builder = {};
+  for (const [key, endpoint] of typedEntries(contract.endpoints)) {
+    if (endpoint.expose && !endpoint.expose.includes("HTTP"))
+      continue;
+    setClientMethod(builder, key, (args) => {
+      const plan = planClientRequest(endpoint, contract.meta.prefix, args ?? {}, contractConfig);
+      if (endpoint.method !== "GET" && endpoint.method !== "DELETE" && Object.keys(plan.remainingArgs).length > 0) {
+        const fields = Object.keys(plan.remainingArgs).join(", ");
+        throw new Error(`URL builder for ${endpoint.method} ${endpoint.path} received non-URL fields: ${fields}`);
+      }
+      return joinClientBaseUrl(source.baseUrl, plan.relativeUrl);
+    });
+  }
+  return builder;
+}
+function createUrlBuilders(contracts, source, contractConfig) {
+  return mapObject(contracts, (_key, contract) => createUrlBuilder(contract, source, contractConfig));
+}
+function createScopedUrlBuilders(contracts, source, scopeConfigs) {
+  return buildScopedRegistry(contracts, scopeConfigs, "URL builder", (contract, config) => createUrlBuilder(contract, source, config));
+}
 
-export { ApiError, createClient, createClients };
+export { randomHex, createTraceContext, parseTraceparent, formatTraceparent, childSpan, ApiError, createHttpClient, formatZodError, zodIssues, parseSSE, parseNDJSON, contractEndpointMatchers, createClient, createClients, createScopedClients, createUrlBuilder, createUrlBuilders, createScopedUrlBuilders };

package/dist/{index-8eywc9zv.js → index-kw12fsbc.js}

@@ -96,5 +96,4 @@ var ApplicationShutdownResultSchema = z.object({
   resources: z.array(ApplicationResourceShutdownSchema).readonly(),
   durationMs: z.number().nonnegative()
 }).readonly();
-
 export { ApplicationIdSchema, ApplicationLifecycleSchema, ApplicationHealthSchema, ManagedResourceStateSchema, ApplicationAdmissionSnapshotSchema, ManagedResourceSnapshotSchema, ApplicationSnapshotSchema, ApplicationStatusProjectionSchema, projectApplicationStatus, ApplicationResourceShutdownSchema, ApplicationShutdownResultSchema };