apps 0.0.1-beta.2 → 0.0.1-beta.20

package/js/chunk-F2IASQK2.js

@@ -0,0 +1,507 @@
+import {
+  skillFromFiles
+} from "./chunk-IPI4MFSN.js";
+import {
+  joinPath,
+  mergeMeta
+} from "./chunk-NMKHTJOQ.js";
+import {
+  parseProviderError
+} from "./chunk-MKWZPDR6.js";
+import {
+  ApiErrorResponse,
+  HostDeclarationInvalid,
+  HostEvaluationFailed,
+  HostedRouter,
+  HostedTool,
+  HostedToolSummary,
+  McpError,
+  maxFailureMessageLength
+} from "./chunk-VXWY44LE.js";
+import {
+  AppDatabaseError
+} from "./chunk-N7YDVXYJ.js";
+import {
+  SkillLoadFailed,
+  skillFormatLimits
+} from "./chunk-JU7VHODU.js";
+import {
+  jsonSchemaDocument
+} from "./chunk-4QQ62BVS.js";
+import {
+  AppStorageError,
+  AppStorageUnavailable
+} from "./chunk-PZB6T6KU.js";
+import {
+  AccountId,
+  HttpUrl,
+  JsonObject
+} from "./chunk-27F7W2LG.js";
+import {
+  Cause_exports,
+  Effect_exports,
+  Option_exports,
+  Predicate_exports,
+  Redacted_exports,
+  Result_exports,
+  Schema_exports
+} from "./chunk-CDL5PM2Q.js";
+
+// src/contracts/openapi.ts
+var OpenapiErrorResponse = Schema_exports.Struct({
+  code: ApiErrorResponse.fields.code,
+  status: ApiErrorResponse.fields.status,
+  message: Schema_exports.Union([
+    Schema_exports.Struct({ source: Schema_exports.Literal("body") }),
+    Schema_exports.Struct({ source: Schema_exports.Literal("schema"), value: ApiErrorResponse.fields.message })
+  ]),
+  schema: JsonObject
+});
+var OpenapiParameter = Schema_exports.Struct({
+  name: Schema_exports.String,
+  in: Schema_exports.Literals(["path", "query", "header", "cookie"]),
+  required: Schema_exports.optionalKey(Schema_exports.Boolean),
+  schema: Schema_exports.optionalKey(JsonObject),
+  style: Schema_exports.optionalKey(Schema_exports.String),
+  explode: Schema_exports.optionalKey(Schema_exports.Boolean),
+  allowReserved: Schema_exports.optionalKey(Schema_exports.Boolean),
+  allowEmptyValue: Schema_exports.optionalKey(Schema_exports.Boolean),
+  content: Schema_exports.optionalKey(JsonObject)
+});
+var OpenapiRequestBody = Schema_exports.Struct({
+  required: Schema_exports.optionalKey(Schema_exports.Boolean),
+  content: Schema_exports.Record(
+    Schema_exports.String,
+    Schema_exports.Struct({
+      schema: Schema_exports.optionalKey(JsonObject),
+      encoding: Schema_exports.optionalKey(JsonObject)
+    })
+  )
+});
+var OpenapiOperation = Schema_exports.Struct({
+  /** The tool name after `queries.` or `mutations.`, grouped as `<group>.<leaf>`. */
+  name: Schema_exports.NonEmptyString,
+  /** The document's operationId, when it declares one. `kinds` overrides are keyed by it. */
+  operationId: Schema_exports.optionalKey(Schema_exports.String),
+  description: Schema_exports.String,
+  method: Schema_exports.Literals(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]),
+  path: Schema_exports.String,
+  baseUrl: HttpUrl,
+  openapi: Schema_exports.String,
+  securitySchemes: Schema_exports.Record(Schema_exports.String, JsonObject),
+  /** The resolved OpenAPI Operation Object; Executor schemas remain separate. */
+  request: Schema_exports.Struct({
+    parameters: Schema_exports.Array(OpenapiParameter),
+    requestBody: Schema_exports.optionalKey(OpenapiRequestBody),
+    security: Schema_exports.Array(Schema_exports.Record(Schema_exports.String, Schema_exports.Array(Schema_exports.String))),
+    responses: Schema_exports.Record(Schema_exports.String, JsonObject)
+  }),
+  /** Streams remain in the metadata but cannot run through a single-result tool call. */
+  streaming: Schema_exports.optionalKey(Schema_exports.Literal(true)),
+  /** The operation's OpenAPI tags, shown to agents as labels within its router. */
+  tags: Schema_exports.optionalKey(Schema_exports.Array(Schema_exports.NonEmptyString)),
+  input: JsonObject,
+  outputSchema: Schema_exports.optionalKey(JsonObject),
+  errorResponses: Schema_exports.optionalKey(Schema_exports.Array(OpenapiErrorResponse))
+});
+var CredentialBinding = Schema_exports.Struct({
+  scheme: Schema_exports.String,
+  field: Schema_exports.String,
+  part: Schema_exports.Literals(["value", "username", "password"]),
+  prefix: Schema_exports.String
+});
+var OpenapiAccount = Schema_exports.Struct({
+  id: Schema_exports.optional(AccountId),
+  method: Schema_exports.String,
+  fields: Schema_exports.Record(Schema_exports.String, Schema_exports.Unknown)
+});
+var OpenapiParameterDefaults = Schema_exports.Struct({
+  path: Schema_exports.optionalKey(Schema_exports.Record(Schema_exports.String, Schema_exports.String)),
+  query: Schema_exports.optionalKey(Schema_exports.Record(Schema_exports.String, Schema_exports.String)),
+  headers: Schema_exports.optionalKey(Schema_exports.Record(Schema_exports.String, Schema_exports.String))
+});
+var OpenapiToolsOptions = Schema_exports.Struct({
+  operations: Schema_exports.Array(OpenapiOperation),
+  /**
+   * Component schemas stored once per app and referenced as `#/$defs/<name>`. Operations
+   * generated before shared definitions carry their own `$defs` and omit this.
+   */
+  definitions: Schema_exports.optional(Schema_exports.Record(Schema_exports.String, JsonObject)),
+  methods: Schema_exports.Record(Schema_exports.String, Schema_exports.Array(CredentialBinding)),
+  oauth: Schema_exports.Array(Schema_exports.String),
+  account: Schema_exports.optional(OpenapiAccount),
+  parameterDefaults: Schema_exports.optional(OpenapiParameterDefaults),
+  signal: Schema_exports.optional(Schema_exports.instanceOf(AbortSignal)),
+  fetch: Schema_exports.optional(
+    Schema_exports.declare((value) => typeof value === "function")
+  )
+});
+var OpenapiError = class extends Schema_exports.TaggedError()("OpenapiError", {
+  reason: Schema_exports.Literals(["invalid_definition", "invalid_input", "request"]),
+  status: Schema_exports.optional(Schema_exports.Number)
+}) {
+};
+var defaultOpenapiResponseLimits = {
+  maxBodyBytes: 16777216,
+  readTimeoutMs: 3e4
+};
+var isOpenapiTextMedia = (type) => /^(?:text\/|application\/(?:[\w.-]+\+)?(?:json|xml)|application\/(?:javascript|x-ndjson|x-www-form-urlencoded))/i.test(
+  type
+);
+var isOpenapiFileSchema = (shape) => shape.contentMediaType !== void 0 && shape.contentEncoding === void 0 || shape.type === "string" && shape.format === "binary";
+var openapiBinaryResultSchema = {
+  type: "object",
+  properties: {
+    base64: { type: "string", contentEncoding: "base64" },
+    contentType: { type: "string" }
+  },
+  required: ["base64", "contentType"],
+  additionalProperties: false
+};
+var openapiMediaKind = (type) => type.includes("json") && !type.includes("ndjson") ? "json" : type === "application/x-www-form-urlencoded" ? "form" : type === "multipart/form-data" ? "multipart" : isOpenapiTextMedia(type) ? "text" : "binary";
+
+// src/implementation/failure-detail.ts
+var storageMessages = {
+  schema: "The app's database schema is invalid.",
+  schema_changed: "The app's database schema changed during this operation. Retry it.",
+  table: "The operation used a table the app's database schema does not declare.",
+  index: "The operation used an index the table does not declare, or used it incorrectly.",
+  range: "The index range is invalid for the declared index.",
+  value: "A value does not match the table's declared field schema.",
+  readonly: "Queries cannot write. Move writes into a mutation.",
+  cursor: "The pagination cursor is invalid or belongs to a different query.",
+  limit: "The operation exceeded a per-invocation app data limit.",
+  closed: "The database session closed before this operation finished.",
+  storage: "App storage failed to complete the operation.",
+  replay: "A workflow step replayed with different input than its first run."
+};
+var minimumSecretLength = 6;
+var secretValues = (value, found) => {
+  if (typeof value === "string") {
+    if (value.length >= minimumSecretLength) found.add(value);
+  } else if (Array.isArray(value)) for (const item of value) secretValues(item, found);
+  else if (Predicate_exports.isObject(value))
+    for (const item of Object.values(value)) secretValues(item, found);
+  return found;
+};
+var accountFieldSecrets = (accounts) => {
+  const found = /* @__PURE__ */ new Set();
+  if (Predicate_exports.isObject(accounts)) {
+    for (const slot of Object.values(accounts))
+      for (const account of Array.isArray(slot) ? slot : [slot])
+        if (Predicate_exports.hasProperty(account, "fields")) secretValues(account.fields, found);
+  }
+  return [...found].sort((a, b) => b.length - a.length);
+};
+var accountSecrets = (accounts) => accountFieldSecrets(Redacted_exports.value(accounts));
+var boundFailureMessage = (message, secrets) => {
+  let redacted = message;
+  for (const secret of secrets) redacted = redacted.split(secret).join("[redacted]");
+  return redacted.length <= maxFailureMessageLength ? redacted : `${redacted.slice(0, maxFailureMessageLength - 1)}\u2026`;
+};
+var errorName = (error) => (error.name.length > 0 ? error.name : "Error").slice(0, 128);
+var ownMessage = (error) => {
+  const cause = error.cause;
+  const suffix = cause instanceof Error && cause.message.length > 0 ? ` (caused by ${errorName(cause)}: ${cause.message})` : "";
+  return error.message.length > 0 ? `${error.message}${suffix}` : void 0;
+};
+var describeFailure = (error) => error instanceof Error ? `${errorName(error)}: ${ownMessage(error) ?? "(no message)"}` : typeof error === "string" ? error : `A non-Error ${error === null ? "null" : typeof error} value was thrown`;
+var failureDetail = (error, secrets) => {
+  if (Schema_exports.is(AppDatabaseError)(error))
+    return {
+      source: "storage",
+      errorName: "AppDatabaseError",
+      code: error.reason,
+      message: boundFailureMessage(ownMessage(error) ?? storageMessages[error.reason], secrets)
+    };
+  if (Schema_exports.is(AppStorageUnavailable)(error))
+    return {
+      source: "storage",
+      errorName: "AppStorageUnavailable",
+      message: "App storage is not available on this host."
+    };
+  if (Schema_exports.is(AppStorageError)(error))
+    return {
+      source: "storage",
+      errorName: "AppStorageError",
+      message: "App storage failed to complete the operation."
+    };
+  if (Schema_exports.is(OpenapiError)(error))
+    return {
+      source: "service",
+      errorName: "OpenapiError",
+      code: error.reason,
+      message: error.reason === "request" ? error.status === void 0 ? "The API request failed before a response arrived." : `The API responded with HTTP ${error.status}, which its OpenAPI document does not declare as an error with a message.` : error.reason === "invalid_input" ? "The input could not be encoded as a request for this API operation." : "The API's OpenAPI definition for this operation is invalid."
+    };
+  if (error instanceof Error)
+    return {
+      source: "app",
+      errorName: errorName(error),
+      message: boundFailureMessage(
+        ownMessage(error) ?? `${errorName(error)} was thrown without a message.`,
+        secrets
+      )
+    };
+  if (typeof error === "string")
+    return { source: "app", errorName: "string", message: boundFailureMessage(error, secrets) };
+  return {
+    source: "app",
+    errorName: typeof error,
+    message: `A non-Error ${error === null ? "null" : typeof error} value was thrown.`
+  };
+};
+
+// src/implementation/router-catalog.ts
+var safeFailure = (error, secrets) => {
+  const provider = parseProviderError(error);
+  if (Option_exports.isSome(provider)) return provider.value;
+  const skills = Schema_exports.decodeUnknownOption(SkillLoadFailed)(error);
+  if (Option_exports.isSome(skills)) {
+    const { reason, message, status } = skills.value;
+    return new SkillLoadFailed({
+      reason,
+      ...message ? { message } : {},
+      ...status === void 0 ? {} : { status }
+    });
+  }
+  const mcp = Schema_exports.decodeUnknownOption(McpError)(error);
+  if (Option_exports.isSome(mcp)) {
+    const { phase, reason, status } = mcp.value;
+    return new McpError({ phase, reason, ...status === void 0 ? {} : { status } });
+  }
+  if (Schema_exports.is(HostDeclarationInvalid)(error)) return error;
+  return new HostEvaluationFailed(failureDetail(error, secrets));
+};
+var sourced = (work, secrets) => Effect_exports.suspend(work).pipe(
+  Effect_exports.catchCause(
+    (cause) => Cause_exports.hasInterrupts(cause) ? Effect_exports.interrupt : Effect_exports.fail(safeFailure(Cause_exports.squash(cause), secrets))
+  )
+);
+var routerMeta = (node, secrets) => node.kind === "router" ? Effect_exports.succeed(node.meta) : node.meta === void 0 ? Effect_exports.succeed(node.overrides) : sourced(node.meta, secrets).pipe(Effect_exports.map((meta) => mergeMeta(meta, node.overrides)));
+var routerSkillPrefix = "tools";
+var plainSegment = /^[a-z][a-z0-9]*$/;
+var pathHash = (path) => {
+  let hash = 2166136261;
+  for (let index = 0; index < path.length; index++)
+    hash = Math.imul(hash ^ path.charCodeAt(index), 16777619) >>> 0;
+  return hash.toString().padStart(10, "0");
+};
+var routerSkillName = (path) => {
+  if (path === "") return routerSkillPrefix;
+  const segments = path.split(".");
+  const plain = [routerSkillPrefix, ...segments].join("-");
+  if (segments.every((segment) => plainSegment.test(segment)) && plain.length <= skillFormatLimits.nameCharacters)
+    return plain;
+  const hash = pathHash(path);
+  const slug = path.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, skillFormatLimits.nameCharacters - routerSkillPrefix.length - hash.length - 2).replace(/^-+|-+$/g, "");
+  return [routerSkillPrefix, slug, hash].filter((part) => part !== "").join("-");
+};
+var entry = (path, meta, error) => Schema_exports.decodeUnknownEffect(HostedRouter)({
+  path,
+  ...meta?.title === void 0 ? {} : { title: meta.title },
+  ...meta?.description === void 0 ? {} : { description: meta.description },
+  ...meta?.icons === void 0 ? {} : { icons: meta.icons },
+  ...meta?.tags === void 0 ? {} : { tags: meta.tags },
+  ...meta?.instructions === void 0 ? {} : { skill: routerSkillName(path) },
+  ...error === void 0 ? {} : { error }
+}).pipe(Effect_exports.mapError(() => new HostDeclarationInvalid()));
+var invalid = (work) => work.pipe(
+  Effect_exports.catchCause(
+    (cause) => Cause_exports.hasInterrupts(cause) ? Effect_exports.interrupt : Effect_exports.fail(new HostDeclarationInvalid())
+  )
+);
+var summaryFields = (name, router, operation, schedules) => {
+  const readOnly = operation.kind === "query";
+  return {
+    name,
+    ...router === "" ? {} : { router },
+    ...schedules === void 0 ? {} : { schedules },
+    description: operation.description ?? `${readOnly ? "Query" : "Mutate"} ${name}`,
+    ...operation.title === void 0 ? {} : { title: operation.title },
+    readOnly,
+    annotations: { ...operation.annotations, readOnlyHint: readOnly }
+  };
+};
+var operationSummary = (name, router, operation, schedules) => invalid(
+  Schema_exports.decodeUnknownEffect(HostedToolSummary)(
+    summaryFields(name, router, operation, schedules)
+  )
+);
+var operationDescription = (name, router, operation, schedules) => invalid(
+  Effect_exports.gen(function* () {
+    return yield* Schema_exports.decodeUnknownEffect(HostedTool)({
+      ...summaryFields(name, router, operation, schedules),
+      inputSchema: yield* jsonSchemaDocument(operation.input),
+      ...operation.output === void 0 ? operation.outputSchema === void 0 ? {} : { outputSchema: operation.outputSchema } : { outputSchema: yield* jsonSchemaDocument(operation.output) },
+      ...operation._meta === void 0 ? {} : { _meta: operation._meta }
+    });
+  })
+);
+var fixedRouter = (operations, meta) => ({
+  kind: "dynamic",
+  ...meta === void 0 ? {} : { meta: () => Effect_exports.succeed(meta) },
+  list: () => Effect_exports.forEach(
+    Object.entries(operations),
+    ([name, operation]) => operationDescription(name, "", operation)
+  ),
+  summaries: () => Effect_exports.forEach(
+    Object.entries(operations),
+    ([name, operation]) => operationSummary(name, "", operation)
+  ),
+  describe: (name) => {
+    const operation = Object.hasOwn(operations, name) ? operations[name] : void 0;
+    return operation === void 0 ? Effect_exports.succeed(void 0) : operationDescription(name, "", operation);
+  },
+  resolve: (name) => Effect_exports.succeed(Object.hasOwn(operations, name) ? operations[name] : void 0)
+});
+var within = (wanted, path) => [...wanted].flatMap(
+  (name) => path === "" ? [name] : name.startsWith(`${path}.`) ? [name.slice(path.length + 1)] : []
+);
+var readCatalog = (root, options) => Effect_exports.gen(function* () {
+  const tools = [];
+  const routers = [];
+  const { wanted, secrets } = options;
+  const readSource = (source, path, relative) => Effect_exports.gen(function* () {
+    const describe = source.describe;
+    const [meta, listed] = yield* Effect_exports.all(
+      [
+        routerMeta(source, secrets),
+        options.summary && source.summaries !== void 0 ? sourced(source.summaries, secrets) : relative !== void 0 && describe !== void 0 ? sourced(
+          () => Effect_exports.forEach(relative, (name) => describe(name), {
+            concurrency: "unbounded"
+          }),
+          secrets
+        ).pipe(Effect_exports.map((tools2) => tools2.filter((tool) => tool !== void 0))) : sourced(source.list, secrets)
+      ],
+      { concurrency: "unbounded" }
+    );
+    const parsed = yield* Schema_exports.decodeUnknownEffect(
+      Schema_exports.Array(options.summary ? HostedToolSummary : HostedTool)
+    )(listed).pipe(Effect_exports.mapError(() => new HostDeclarationInvalid()));
+    const names = /* @__PURE__ */ new Set();
+    const found = [];
+    for (const tool of parsed) {
+      if (names.has(tool.name)) return yield* new HostDeclarationInvalid();
+      names.add(tool.name);
+      if (relative !== void 0 && !relative.includes(tool.name)) continue;
+      const readOnly = tool.readOnly === true;
+      found.push({
+        ...tool,
+        name: joinPath(path, tool.name),
+        ...path === "" ? {} : { router: path },
+        readOnly,
+        annotations: { ...tool.annotations, readOnlyHint: readOnly }
+      });
+    }
+    return { meta, found };
+  });
+  const include = (source, path, relative) => Effect_exports.gen(function* () {
+    if (path === "") {
+      const { meta, found } = yield* readSource(source, path, relative);
+      tools.push(...found);
+      return { meta, error: void 0 };
+    }
+    const result = yield* Effect_exports.result(readSource(source, path, relative));
+    if (Result_exports.isFailure(result)) return { meta: source.overrides, error: result.failure };
+    tools.push(...result.success.found);
+    return { meta: result.success.meta, error: void 0 };
+  });
+  const visit = (node, path) => Effect_exports.gen(function* () {
+    if (path !== "" || wanted === void 0 && node.meta !== void 0)
+      routers.push(yield* entry(path, node.meta));
+    for (const [key, child] of Object.entries(node.children)) {
+      const name = joinPath(path, key);
+      switch (child.kind) {
+        case "query":
+        case "mutation":
+          if (options.scheduled === true && options.schedules(name).length === 0) break;
+          if (wanted === void 0 || wanted.has(name))
+            tools.push(
+              options.summary ? yield* operationSummary(name, path, child, options.schedules(name)) : yield* operationDescription(name, path, child, options.schedules(name))
+            );
+          break;
+        case "router":
+          if (wanted === void 0 || within(wanted, name).length > 0)
+            yield* visit(child, name);
+          break;
+        case "dynamic": {
+          if (options.scheduled === true) break;
+          const relative = wanted === void 0 ? void 0 : within(wanted, name);
+          if (relative !== void 0 && relative.length === 0) break;
+          const read = yield* include(child, name, relative);
+          routers.push(yield* entry(name, read.meta, read.error));
+        }
+      }
+    }
+  });
+  if (root?.kind === "router") yield* visit(root, "");
+  else if (root?.kind === "dynamic" && options.scheduled !== true) {
+    const read = yield* include(root, "", wanted === void 0 ? void 0 : [...wanted]);
+    if (wanted === void 0 && read.meta !== void 0)
+      routers.push(yield* entry("", read.meta));
+  }
+  return { tools, routers };
+});
+var routerSkills = (root) => Effect_exports.gen(function* () {
+  const nodes = [];
+  const collect = (node, path) => {
+    nodes.push({ path, node });
+    if (node.kind === "router") {
+      for (const [key, child] of Object.entries(node.children))
+        if (child.kind === "router" || child.kind === "dynamic")
+          collect(child, joinPath(path, key));
+    }
+  };
+  if (root !== void 0) collect(root, "");
+  const skills = yield* Effect_exports.forEach(
+    nodes,
+    ({ path, node }) => (
+      // Skills that fail are skipped, so their failures are never reported.
+      routerMeta(node, []).pipe(
+        Effect_exports.flatMap((meta) => routerSkill(path, meta)),
+        Effect_exports.orElseSucceed(() => void 0)
+      )
+    ),
+    { concurrency: "unbounded" }
+  );
+  const names = /* @__PURE__ */ new Set();
+  return skills.filter((skill) => {
+    if (skill === void 0 || names.has(skill.name)) return false;
+    names.add(skill.name);
+    return true;
+  });
+});
+var routerSkill = (path, meta) => Effect_exports.gen(function* () {
+  if (meta?.instructions === void 0) return void 0;
+  const name = routerSkillName(path);
+  const description = ([meta.description, meta.title].find((text) => text !== void 0 && text.trim() !== "") ?? (path === "" ? "How to use this app's tools" : `How to use the ${path} tools`)).slice(0, skillFormatLimits.descriptionCharacters);
+  const content = `---
+name: ${name}
+description: ${JSON.stringify(description)}
+---
+
+${meta.instructions}
+`;
+  return yield* skillFromFiles([{ path: "SKILL.md", content }], { name });
+});
+
+export {
+  OpenapiErrorResponse,
+  OpenapiParameter,
+  OpenapiRequestBody,
+  OpenapiOperation,
+  OpenapiToolsOptions,
+  OpenapiError,
+  defaultOpenapiResponseLimits,
+  isOpenapiTextMedia,
+  isOpenapiFileSchema,
+  openapiBinaryResultSchema,
+  openapiMediaKind,
+  accountSecrets,
+  boundFailureMessage,
+  describeFailure,
+  failureDetail,
+  fixedRouter,
+  readCatalog,
+  routerSkills
+};

package/js/{chunk-Z5NMEGJN.js → chunk-HQY4UTYX.js}

@@ -1,13 +1,17 @@
 import {
-  operationDeclaration
-} from "./chunk-PYUYJRSK.js";
+  fixedRouter
+} from "./chunk-F2IASQK2.js";
+import {
+  nativeOperation,
+  operationDeclaration,
+  routerDeclaration
+} from "./chunk-NMKHTJOQ.js";
 
 // src/implementation/protocol-operations.ts
 var protocolOperations = (operations, kinds = {}) => {
-  const queries = {};
-  const mutations = {};
+  const declared = {};
   for (const [name, operation] of Object.entries(operations)) {
-    const kind = Object.hasOwn(kinds, name) ? kinds[name] : operation.readOnly === true ? "query" : "mutation";
+    const kind = Object.hasOwn(kinds, name) ? kinds[name] ?? "mutation" : operation.readOnly === true ? "query" : "mutation";
     const native = {
       description: operation.description,
       ...operation.title === void 0 ? {} : { title: operation.title },
@@ -18,12 +22,20 @@ var protocolOperations = (operations, kinds = {}) => {
     };
     const output = Object.getOwnPropertyDescriptor(operation, "outputSchema");
     const withOutput = (target) => output === void 0 || output.get === void 0 && output.value === void 0 ? target : Object.defineProperty(target, "outputSchema", { ...output, enumerable: true });
-    if (kind === "query") queries[name] = operationDeclaration(withOutput({ ...native, kind }));
-    else mutations[name] = operationDeclaration(withOutput({ ...native, kind: "mutation" }));
+    declared[name] = operationDeclaration(withOutput({ ...native, kind }));
+  }
+  return declared;
+};
+var protocolRouter = (operations, kinds = {}) => {
+  const native = {};
+  for (const [name, declaration] of Object.entries(protocolOperations(operations, kinds))) {
+    const operation = nativeOperation(declaration);
+    if (operation !== void 0) native[name] = operation;
   }
-  return { queries, mutations };
+  return routerDeclaration(fixedRouter(native));
 };
 
 export {
-  protocolOperations
+  protocolOperations,
+  protocolRouter
 };

package/js/{chunk-OHRT55C4.js → chunk-IJX4CYZO.js}

@@ -19,10 +19,10 @@ import {
   text,
   uint8Array,
   urlParams
-} from "./chunk-QKHR7BMF.js";
+} from "./chunk-UK573G7W.js";
 import {
   JsonValue
-} from "./chunk-SATWJKN6.js";
+} from "./chunk-27F7W2LG.js";
 import {
   Cause,
   Defect,
@@ -118,7 +118,7 @@ import {
   transformEffect,
   transformPull,
   void_2 as void_
-} from "./chunk-FW5HBOIK.js";
+} from "./chunk-CDL5PM2Q.js";
 import {
   __export
 } from "./chunk-CZ7CSFO4.js";
@@ -1784,10 +1784,7 @@ var AppUiApi = HttpApi_exports.make("app-ui").add(
 );
 
 export {
-  HttpApiEndpoint_exports,
-  HttpApi_exports,
   HttpApiClient_exports,
-  HttpApiGroup_exports,
   UiContext,
   UiOperation,
   UiUnauthorized,

package/js/{chunk-FDNTX5QJ.js → chunk-IPI4MFSN.js}

@@ -5,11 +5,11 @@ import {
   SkillDefinitionInvalid,
   SkillFile,
   SkillFilePath
-} from "./chunk-YEJOQEII.js";
+} from "./chunk-JU7VHODU.js";
 import {
   Effect_exports,
   Schema_exports
-} from "./chunk-FW5HBOIK.js";
+} from "./chunk-CDL5PM2Q.js";
 
 // src/implementation/skill-files.ts
 var skillFromFiles = (input, source = {}) => Effect_exports.gen(function* () {

package/js/{chunk-YEJOQEII.js → chunk-JU7VHODU.js}

@@ -1,6 +1,6 @@
 import {
   Schema_exports
-} from "./chunk-FW5HBOIK.js";
+} from "./chunk-CDL5PM2Q.js";
 
 // src/contracts/skills.ts
 var SkillFilePath = Schema_exports.NonEmptyString.check(

package/js/chunk-KUMBKVJD.js

@@ -0,0 +1,39 @@
+import {
+  appSignInCallbackPath
+} from "./chunk-VFZKSM3T.js";
+import {
+  HttpServerResponse_exports
+} from "./chunk-UK573G7W.js";
+
+// src/implementation/ui-auth.ts
+var appPrivateHeaders = {
+  "cache-control": "no-store",
+  "referrer-policy": "no-referrer",
+  "x-content-type-options": "nosniff",
+  "content-security-policy": "frame-ancestors 'none'"
+};
+var appRedirect = (url) => HttpServerResponse_exports.redirect(url, { status: 302, headers: appPrivateHeaders });
+var appSignInCallback = (origin, request, code) => {
+  const callback = new URL(appSignInCallbackPath, origin);
+  callback.searchParams.set("request", request);
+  callback.searchParams.set("code", code);
+  return callback.href;
+};
+var appSignInFailed = () => HttpServerResponse_exports.text(
+  `<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Could not open app</title></head><body><p>Could not sign in to this app. Try opening it again.</p><a href="/">Try again</a></body></html>`,
+  {
+    status: 401,
+    contentType: "text/html",
+    headers: {
+      ...appPrivateHeaders,
+      "content-security-policy": "default-src 'none'; frame-ancestors 'none'; base-uri 'none'"
+    }
+  }
+);
+
+export {
+  appPrivateHeaders,
+  appRedirect,
+  appSignInCallback,
+  appSignInFailed
+};

package/js/{chunk-EVJUVWN2.js → chunk-M3B3DE4K.js}

@@ -3,7 +3,7 @@ import {
   invalidate,
   layer,
   mutation
-} from "./chunk-M6ZRRIBI.js";
+} from "./chunk-PJJ24GU7.js";
 import {
   Boolean,
   Cause,
@@ -158,7 +158,7 @@ import {
   void_2,
   whileLoop,
   zipRight
-} from "./chunk-FW5HBOIK.js";
+} from "./chunk-CDL5PM2Q.js";
 import {
   __export
 } from "./chunk-CZ7CSFO4.js";