apps 0.0.1-beta.9 → 0.0.1-beta.91

package/js/chunk-DADXWWRZ.js

@@ -0,0 +1,449 @@
+import {
+  declaredOperations,
+  nativeOperation,
+  nativeRouter
+} from "./chunk-YWFUWTUJ.js";
+import {
+  fromPromise,
+  method
+} from "./chunk-I5C7FD5Z.js";
+import {
+  EmittedEvent,
+  EventName,
+  Placement,
+  ScheduleTiming,
+  appIconsProblem,
+  defaultEventLimits,
+  normalizePlacements,
+  placementFields,
+  renderPlacement
+} from "./chunk-6XQLA5NC.js";
+import {
+  decoderOf,
+  isSchema,
+  jsonSchemaDocument,
+  schemaArgument
+} from "./chunk-GQ33QSNB.js";
+import {
+  JsonValue
+} from "./chunk-DDHBUKXX.js";
+import {
+  Effect_exports,
+  Result_exports,
+  Schema_exports
+} from "./chunk-IFJU5SYQ.js";
+
+// src/contracts/http.ts
+var ResponseStatusError = class extends Schema_exports.TaggedError()(
+  "ResponseStatusError",
+  { status: Schema_exports.Number }
+) {
+  get message() {
+    return `Request failed with status ${this.status}`;
+  }
+};
+var ResponseDecodeError = class extends Schema_exports.TaggedError()(
+  "ResponseDecodeError",
+  {}
+) {
+  get message() {
+    return "Response body did not match the expected schema";
+  }
+};
+
+// src/implementation/placement.ts
+var misuse = (name) => `${name} is a credential placement, not a string. Build placement values with t\`...\`, such as t\`Bearer \${token}\`, instead of an untagged template literal or string concatenation.`;
+var NotAString = class {
+  #described;
+  constructor(described) {
+    this.#described = described;
+  }
+  [Symbol.toPrimitive]() {
+    throw new TypeError(misuse(this.#described));
+  }
+  toString() {
+    throw new TypeError(misuse(this.#described));
+  }
+  toJSON() {
+    throw new TypeError(misuse(this.#described));
+  }
+};
+var FieldRef = class extends NotAString {
+  field;
+  constructor(field) {
+    super(`The field reference ${JSON.stringify(field)}`);
+    this.field = field;
+  }
+};
+var PlacementValue = class extends NotAString {
+  parts;
+  constructor(parts) {
+    super("A t`...` value");
+    this.parts = parts;
+  }
+};
+var partsOf = (input) => {
+  if (typeof input === "string") return input === "" ? [] : [input];
+  if (input instanceof FieldRef) return [{ field: input.field }];
+  if (input instanceof PlacementValue) return input.parts;
+  throw new TypeError(
+    `A credential placement interpolates text, a field reference, t\`...\` or base64(...), not ${typeof input}.`
+  );
+};
+var joined = (parts) => parts.reduce((all, part) => {
+  const last = all.at(-1);
+  if (typeof part === "string" && typeof last === "string") all[all.length - 1] = last + part;
+  else all.push(part);
+  return all;
+}, []);
+var t = (strings, ...values) => new PlacementValue(
+  joined(
+    strings.flatMap((text, index) => [
+      ...partsOf(text),
+      ...index < values.length ? partsOf(values[index]) : []
+    ])
+  )
+);
+var base64 = (value2) => {
+  const inner = partsOf(value2).map((part) => {
+    if (typeof part === "object" && "base64" in part)
+      throw new TypeError("base64(...) cannot contain another base64(...).");
+    return part;
+  });
+  if (inner.length === 0) throw new TypeError("base64(...) needs a value.");
+  return new PlacementValue([{ base64: inner }]);
+};
+var value = (input) => {
+  const parts = partsOf(input);
+  if (parts.length === 0) throw new TypeError("A credential placement needs a value.");
+  return joined(parts);
+};
+var header = (name, input) => ({
+  in: "header",
+  name: name.toLowerCase(),
+  value: value(input)
+});
+var query = (name, input) => ({
+  in: "query",
+  name,
+  value: value(input)
+});
+var bearer = (token) => header("authorization", t`Bearer ${token}`);
+var basic = (user, password) => header("authorization", t`Basic ${base64(t`${user}:${password}`)}`);
+var declarePlacements = (method2, names, exposure, request) => {
+  const declared = new Set(names);
+  const refs = new Proxy(Object.fromEntries(names.map((name) => [name, new FieldRef(name)])), {
+    get: (target, key) => {
+      if (typeof key === "string" && !declared.has(key))
+        throw new TypeError(
+          `The ${method2} request references "${key}", which is not one of its fields: ${names.join(", ")}.`
+        );
+      return Reflect.get(target, key);
+    }
+  });
+  const returned = request(refs);
+  const placements = Array.isArray(returned) ? returned : [returned];
+  if (placements.length === 0) throw new TypeError(`The ${method2} request declares no placements.`);
+  if (!placements.every(Schema_exports.is(Placement)))
+    throw new TypeError(
+      `The ${method2} request must return header(...) or query(...) placements, or an array of them.`
+    );
+  for (const placement of placements) {
+    const fields = placementFields(placement);
+    for (const field of fields) {
+      if (!declared.has(field))
+        throw new TypeError(
+          `The ${method2} request references "${field}", which is not one of its fields: ${names.join(", ")}.`
+        );
+      if (exposure?.[field] === "raw")
+        throw new TypeError(
+          `The ${method2} request references the raw() field "${field}". App code reads raw fields as real values, so they are never placed; remove raw() or the reference.`
+        );
+    }
+    if (![...fields].some((field) => exposure?.[field] === void 0))
+      throw new TypeError(
+        `The ${method2} request's ${placement.in} ${placement.name} references no secret field. A placement places a secret: reference a field that is not plain() or raw().`
+      );
+  }
+  return normalizePlacements(placements);
+};
+var undeclared = (method2) => `The ${method2} account declares no request. Declare where its credentials go with request, such as request: ({ token }) => bearer(token), to use headers() and url().`;
+var withPlacements = (account, placements) => {
+  const fields = typeof account.fields === "object" && account.fields !== null ? account.fields : {};
+  const render = (placement) => Result_exports.getOrThrowWith(
+    renderPlacement(placement, fields),
+    (error) => new TypeError(error.message)
+  );
+  const declared = () => {
+    if (placements === void 0 || placements.length === 0)
+      throw new TypeError(undeclared(account.method));
+    return placements;
+  };
+  return Object.defineProperties(account, {
+    headers: {
+      enumerable: false,
+      value: () => Object.fromEntries(
+        declared().filter((placement) => placement.in === "header").map((placement) => [placement.name, render(placement)])
+      )
+    },
+    url: {
+      enumerable: false,
+      value: (input) => {
+        const url = new URL(input);
+        for (const placement of declared())
+          if (placement.in === "query") url.searchParams.set(placement.name, render(placement));
+        return url.href;
+      }
+    }
+  });
+};
+
+// src/implementation/workflows.ts
+var NativeWorkflow = /* @__PURE__ */ Symbol("apps.Workflow");
+var workflow = (options, run) => ({
+  [NativeWorkflow]: {
+    input: decoderOf(schemaArgument(options.input, "The workflow input")),
+    ...options.output === void 0 ? {} : { output: decoderOf(schemaArgument(options.output, "The workflow output")) },
+    ...options.description === void 0 ? {} : { description: options.description },
+    // SAFETY: defineApp checks required context; the host supplies the pinned run's capabilities.
+    run: (context, input) => fromPromise(run, "workflow")(context, input)
+  }
+});
+var nativeWorkflow = (value2) => {
+  if (typeof value2 !== "object" || value2 === null || !(NativeWorkflow in value2)) return void 0;
+  return value2[NativeWorkflow];
+};
+
+// src/implementation/events.ts
+var Native = /* @__PURE__ */ Symbol("apps.Event");
+var scalarTypes = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean"]);
+var isScalarSchema = (document) => {
+  const type = document.type;
+  if (typeof type === "string") return scalarTypes.has(type);
+  const choices = Array.isArray(document.enum) ? document.enum : "const" in document ? [document.const] : void 0;
+  return choices !== void 0 && choices.length > 0 && choices.every((value2) => ["string", "number", "boolean"].includes(typeof value2));
+};
+var event = (options) => {
+  const filters = options.filters ?? {};
+  const fieldDecoders = Object.fromEntries(
+    Object.entries(filters).map(([key, field]) => [
+      key,
+      decoderOf(schemaArgument(field, `The event filter ${JSON.stringify(key)}`))
+    ])
+  );
+  for (const [key, decoder] of Object.entries(fieldDecoders)) {
+    const document = Effect_exports.runSync(jsonSchemaDocument(decoder));
+    if (!isScalarSchema(document))
+      throw new TypeError(
+        `The event filter ${JSON.stringify(key)} must be a string, number, boolean or literal`
+      );
+  }
+  return {
+    [Native]: {
+      description: options.description,
+      filters: fieldDecoders,
+      payload: decoderOf(schemaArgument(options.payload, "The event payload"))
+    },
+    description: options.description,
+    filters,
+    payload: options.payload
+  };
+};
+var nativeEvent = (declaration) => typeof declaration === "object" && declaration !== null && Native in declaration ? declaration[Native] : void 0;
+var declaredEvents = (events) => Effect_exports.forEach(
+  Object.entries(events),
+  ([name, declared]) => Effect_exports.gen(function* () {
+    const filters = yield* jsonSchemaDocument(Schema_exports.Struct(declared.filters));
+    const payload = yield* jsonSchemaDocument(declared.payload);
+    return [name, { description: declared.description, filters, payload }];
+  })
+).pipe(Effect_exports.map((entries) => Object.fromEntries(entries)));
+var makeEmitter = (input) => ({
+  emit: (name, data, ...rest) => {
+    const options = rest[0] ?? {};
+    const declared = Object.hasOwn(input.events, name) ? input.events[name] : void 0;
+    if (declared === void 0) throw new TypeError(`This app declares no event named "${name}"`);
+    if (input.emitted.length >= defaultEventLimits.maxEventsPerInvocation)
+      throw new RangeError(
+        `An invocation can emit at most ${defaultEventLimits.maxEventsPerInvocation} events`
+      );
+    const payload = Schema_exports.decodeUnknownSync(declared.payload)(data);
+    const filters = Schema_exports.decodeUnknownSync(Schema_exports.Struct(declared.filters))(
+      options.filters ?? {}
+    );
+    const account = options.account ?? input.sourceAccount ?? (input.attributable.length === 1 ? input.attributable[0] : void 0) ?? null;
+    if (account === null && input.attributable.length > 1)
+      throw new TypeError(
+        "This invocation has several accounts; name the one the event came from with { account }"
+      );
+    if (account !== null && !input.accounts.includes(account))
+      throw new TypeError("The event's account is not one of this invocation's accounts");
+    const occurredAt = options.occurredAt === void 0 ? Date.now() : options.occurredAt instanceof Date ? options.occurredAt.getTime() : options.occurredAt;
+    const occurrence = Schema_exports.decodeUnknownSync(EmittedEvent)({
+      name: Schema_exports.decodeUnknownSync(EventName)(name),
+      id: options.id ?? crypto.randomUUID(),
+      occurredAt,
+      data: payload,
+      filters,
+      account
+    });
+    if (new TextEncoder().encode(JSON.stringify(occurrence.data)).byteLength > defaultEventLimits.maxDataBytes)
+      throw new RangeError(
+        `An event's data can be at most ${defaultEventLimits.maxDataBytes} bytes of JSON; send a summary and a tool to read the rest`
+      );
+    input.emitted.push(occurrence);
+  }
+});
+
+// src/implementation/app.ts
+var InternalApp = /* @__PURE__ */ Symbol("apps.App");
+var isApp = (value2) => typeof value2 === "object" && value2 !== null && InternalApp in value2;
+var toEffectApp = (app) => app[InternalApp];
+function rejectCatalogs(definition) {
+  if ("queries" in definition || "mutations" in definition)
+    throw new Error("Put queries and mutations in a router under tools");
+}
+function adaptDefinition(definition) {
+  rejectCatalogs(definition);
+  const webhooks = definition.webhooks === void 0 ? {} : {
+    // SAFETY: `Required` only where the optional method was just checked to be present.
+    webhooks: Object.fromEntries(
+      Object.entries(definition.webhooks).map(([name, webhook]) => [
+        name,
+        {
+          ...webhook,
+          ...webhook.register === void 0 ? {} : {
+            register: fromPromise(
+              method(webhook, "register"),
+              "webhook"
+            )
+          },
+          handle: fromPromise(method(webhook, "handle"), "webhook"),
+          ...webhook.unregister === void 0 ? {} : {
+            unregister: fromPromise(
+              method(webhook, "unregister"),
+              "webhook"
+            )
+          },
+          ..."config" in webhook && isSchema(webhook.config) ? { config: decoderOf(webhook.config) } : {},
+          ..."state" in webhook && isSchema(webhook.state) ? { state: decoderOf(webhook.state) } : {}
+        }
+      ])
+    )
+  };
+  const workflows = definition.workflows === void 0 ? {} : {
+    workflows: Object.fromEntries(
+      Object.entries(definition.workflows).map(([name, value2]) => {
+        const declared2 = nativeWorkflow(value2);
+        if (declared2 === void 0) throw new Error("Invalid workflow declaration");
+        return [name, declared2];
+      })
+    )
+  };
+  const root = definition.tools === void 0 ? void 0 : nativeRouter(definition.tools);
+  if (definition.tools !== void 0 && root === void 0)
+    throw new Error("tools must be a router");
+  const data = root === void 0 ? {} : { tools: root };
+  const declared = root?.kind === "router" ? declaredOperations(root) : [];
+  const mutations = /* @__PURE__ */ new Set();
+  for (const { operation } of declared) {
+    if (operation.kind !== "mutation") continue;
+    if (mutations.has(operation))
+      throw new Error("A mutation can be mounted at only one path in tools");
+    mutations.add(operation);
+  }
+  const schedules = definition.schedules === void 0 ? {} : {
+    schedules: Object.fromEntries(
+      Object.entries(definition.schedules).map(([name, schedule]) => {
+        const target = nativeOperation(schedule.operation);
+        const match = declared.find(
+          ({ operation }) => operation === target && operation.kind === "mutation"
+        );
+        if (match === void 0)
+          throw new Error("A schedule must reference a mutation in this app's tools");
+        if (schedule.scope === "app" && match.operation.approval !== void 0)
+          throw new Error("An app schedule must reference a mutation without an approval");
+        return [
+          name,
+          {
+            ...schedule.scope === "app" ? { scope: "app" } : {},
+            timing: Schema_exports.decodeUnknownSync(ScheduleTiming)(schedule.timing),
+            input: Schema_exports.decodeUnknownSync(JsonValue)(schedule.input),
+            tool: match.name
+          }
+        ];
+      })
+    )
+  };
+  return {
+    ...definition,
+    ...webhooks,
+    ...workflows,
+    ...data,
+    ...schedules
+  };
+}
+function scopedSlots(requirements) {
+  if ("accounts" in requirements)
+    throw new TypeError(
+      "Declare account requirements by scope: user: { accounts } for each caller's accounts, app: { accounts } for the app's own"
+    );
+  const app = requirements.app?.accounts ?? {};
+  const user = requirements.user?.accounts ?? {};
+  for (const name of Object.keys(app))
+    if (Object.hasOwn(user, name))
+      throw new TypeError(
+        `The requirement ${JSON.stringify(name)} is declared as both an app and a user account; name them differently`
+      );
+  return { app, user };
+}
+var defineApp = (requirements, definition) => {
+  const accounts = scopedSlots(requirements);
+  if (typeof definition !== "function") rejectCatalogs(definition);
+  const evaluate = typeof definition === "function" ? definition : async () => definition;
+  const factory = fromPromise(evaluate, "factory");
+  const events = requirements.events === void 0 ? void 0 : Object.fromEntries(
+    Object.entries(requirements.events).map(([name, declared]) => {
+      const native2 = nativeEvent(declared);
+      if (native2 === void 0)
+        throw new TypeError(
+          `The event ${JSON.stringify(name)} must be declared with event()`
+        );
+      return [name, native2];
+    })
+  );
+  const iconsProblem = requirements.icons === void 0 ? void 0 : appIconsProblem(requirements.icons);
+  if (iconsProblem !== void 0)
+    throw new TypeError(`The app's icons are invalid: ${iconsProblem}`);
+  const native = {
+    accounts,
+    ...events === void 0 ? {} : { events },
+    ...requirements.icons === void 0 || requirements.icons.length === 0 ? {} : { icons: requirements.icons },
+    evaluate: (context) => factory(context).pipe(Effect_exports.map((value2) => adaptDefinition(value2)))
+  };
+  return {
+    [InternalApp]: native,
+    accounts: native.accounts,
+    evaluate: (context) => Effect_exports.runPromise(factory(context))
+  };
+};
+
+export {
+  ResponseStatusError,
+  ResponseDecodeError,
+  t,
+  base64,
+  header,
+  query,
+  bearer,
+  basic,
+  declarePlacements,
+  withPlacements,
+  workflow,
+  event,
+  declaredEvents,
+  makeEmitter,
+  isApp,
+  toEffectApp,
+  defineApp
+};

package/js/{chunk-27F7W2LG.js → chunk-DDHBUKXX.js}

@@ -1,12 +1,12 @@
 import {
   Schema_exports
-} from "./chunk-CDL5PM2Q.js";
+} from "./chunk-IFJU5SYQ.js";
 
 // src/contracts/schema.ts
 var JsonValue = Schema_exports.Json;
 var JsonObject = Schema_exports.Record(Schema_exports.String, JsonValue);
 var AccountId = Schema_exports.String.pipe(
-  Schema_exports.check(Schema_exports.isStartsWith("acc_"), Schema_exports.isMinLength(5)),
+  Schema_exports.check(Schema_exports.isStartingWith("acc_"), Schema_exports.isMinLength(5)),
   Schema_exports.brand("acc")
 );
 var HttpUrl = Schema_exports.String.check(
@@ -19,6 +19,21 @@ var HttpUrl = Schema_exports.String.check(
     }
   })
 );
+var DeclarationIssue = Schema_exports.Struct({
+  path: Schema_exports.Array(Schema_exports.String),
+  message: Schema_exports.String
+});
+var DeclarationInvalid = class extends Schema_exports.TaggedError()(
+  "DeclarationInvalid",
+  { declaration: Schema_exports.String, issues: Schema_exports.Array(DeclarationIssue) }
+) {
+  get message() {
+    const problems = this.issues.map(
+      (issue) => issue.path.length === 0 ? issue.message : `${issue.path.join(".")}: ${issue.message}`
+    );
+    return `The ${this.declaration} declaration is invalid. ${problems.join("; ")}`;
+  }
+};
 var ValidationError = class extends Schema_exports.TaggedError()("ValidationError", {}) {
   get message() {
     return "Value did not match the schema";
@@ -30,5 +45,6 @@ export {
   JsonObject,
   AccountId,
   HttpUrl,
+  DeclarationInvalid,
   ValidationError
 };