apps 0.0.1-beta.4 → 0.0.1-beta.40

package/js/chunk-BMOIAIVR.js

@@ -1,138 +0,0 @@
-import {
-  Schema_exports
-} from "./chunk-FW5HBOIK.js";
-
-// ../app-data/src/contracts/database.ts
-var DataName = Schema_exports.String.check(
-  Schema_exports.makeFilter((value) => /^[A-Za-z][A-Za-z0-9_]*$/.test(value) && value.length <= 128)
-);
-var Scalar = Schema_exports.Union([Schema_exports.String, Schema_exports.Finite, Schema_exports.Boolean]);
-var Field = Schema_exports.Struct({
-  kind: Schema_exports.Literals(["string", "number", "boolean", "id", "userId"]),
-  optional: Schema_exports.optional(Schema_exports.Boolean),
-  default: Schema_exports.optional(Scalar),
-  references: Schema_exports.optional(DataName)
-});
-var Index = Schema_exports.Struct({ name: DataName, fields: Schema_exports.NonEmptyArray(DataName) });
-var Table = Schema_exports.Struct({
-  fields: Schema_exports.Record(DataName, Field),
-  indexes: Schema_exports.Array(Index)
-});
-var DatabaseSchema = Schema_exports.Record(DataName, Table);
-var Row = Schema_exports.Record(Schema_exports.String, Scalar);
-var RowMetadata = Schema_exports.Struct({
-  id: Schema_exports.NonEmptyString,
-  createdAt: Schema_exports.String,
-  updatedAt: Schema_exports.String
-});
-var Patch = Schema_exports.Record(DataName, Schema_exports.NullOr(Scalar));
-var RangeClause = Schema_exports.Struct({
-  field: DataName,
-  op: Schema_exports.Literals(["eq", "gt", "gte", "lt", "lte"]),
-  value: Schema_exports.NullOr(Scalar)
-});
-var QueryPlan = Schema_exports.Struct({
-  table: DataName,
-  index: DataName,
-  order: Schema_exports.Literals(["asc", "desc"]),
-  clauses: Schema_exports.Array(RangeClause)
-});
-var QueryTerminal = Schema_exports.Union([
-  Schema_exports.Struct({ kind: Schema_exports.Literal("collect") }),
-  Schema_exports.Struct({ kind: Schema_exports.Literal("count") }),
-  Schema_exports.Struct({ kind: Schema_exports.Literal("first") }),
-  Schema_exports.Struct({
-    kind: Schema_exports.Literal("take"),
-    count: Schema_exports.Int.check(Schema_exports.isGreaterThanOrEqualTo(0))
-  }),
-  Schema_exports.Struct({
-    kind: Schema_exports.Literal("paginate"),
-    cursor: Schema_exports.NullOr(Schema_exports.String),
-    numItems: Schema_exports.Int.check(Schema_exports.isGreaterThan(0))
-  })
-]);
-var DatabaseOperation = Schema_exports.Union([
-  Schema_exports.Struct({ kind: Schema_exports.Literal("get"), table: DataName, id: Schema_exports.NonEmptyString }),
-  Schema_exports.Struct({ kind: Schema_exports.Literal("insert"), table: DataName, value: Patch }),
-  Schema_exports.Struct({
-    kind: Schema_exports.Literal("update"),
-    table: DataName,
-    id: Schema_exports.NonEmptyString,
-    patch: Patch
-  }),
-  Schema_exports.Struct({ kind: Schema_exports.Literal("delete"), table: DataName, id: Schema_exports.NonEmptyString }),
-  Schema_exports.Struct({ kind: Schema_exports.Literal("query"), plan: QueryPlan, terminal: QueryTerminal })
-]);
-var PaginationResult = Schema_exports.Struct({
-  page: Schema_exports.Array(Row),
-  continueCursor: Schema_exports.NullOr(Schema_exports.String),
-  isDone: Schema_exports.Boolean
-});
-var OperationResult = Schema_exports.Union([
-  Row,
-  Schema_exports.Array(Row),
-  PaginationResult,
-  Schema_exports.Boolean,
-  Schema_exports.Finite,
-  Schema_exports.Null
-]);
-var AppDatabaseError = class extends Schema_exports.TaggedError()("AppDatabaseError", {
-  reason: Schema_exports.Literals([
-    "schema",
-    "schema_changed",
-    "table",
-    "index",
-    "range",
-    "value",
-    "readonly",
-    "cursor",
-    "limit",
-    "closed",
-    "storage",
-    "replay"
-  ])
-}) {
-};
-var DatabaseLimits = Schema_exports.Struct({
-  rowsRead: Schema_exports.Int.check(Schema_exports.isGreaterThan(0)),
-  rowsReturned: Schema_exports.Int.check(Schema_exports.isGreaterThan(0)),
-  bytesRead: Schema_exports.Int.check(Schema_exports.isGreaterThan(0)),
-  writes: Schema_exports.Int.check(Schema_exports.isGreaterThan(0)),
-  scanCalls: Schema_exports.Int.check(Schema_exports.isGreaterThan(0)),
-  directGets: Schema_exports.Int.check(Schema_exports.isGreaterThan(0)),
-  valueBytes: Schema_exports.Int.check(Schema_exports.isGreaterThan(0)),
-  indexBytes: Schema_exports.Int.check(Schema_exports.isGreaterThan(0))
-});
-var defaultDatabaseLimits = {
-  rowsRead: 5e3,
-  rowsReturned: 1e3,
-  bytesRead: 4 * 1024 * 1024,
-  writes: 1e3,
-  scanCalls: 100,
-  directGets: 1e3,
-  valueBytes: 64 * 1024,
-  indexBytes: 2048
-};
-var DatabaseRuntimeLimits = Schema_exports.Struct({
-  maxCursorChars: Schema_exports.Int.check(Schema_exports.isGreaterThan(0)),
-  connectionCacheCapacity: Schema_exports.Int.check(Schema_exports.isGreaterThan(0)),
-  connectionCacheTtlMs: Schema_exports.Int.check(Schema_exports.isGreaterThan(0))
-});
-var defaultDatabaseRuntimeLimits = DatabaseRuntimeLimits.make({
-  maxCursorChars: 8192,
-  connectionCacheCapacity: 64,
-  connectionCacheTtlMs: 5 * 60 * 1e3
-});
-
-export {
-  DatabaseSchema,
-  Row,
-  RowMetadata,
-  RangeClause,
-  DatabaseOperation,
-  PaginationResult,
-  AppDatabaseError,
-  DatabaseLimits,
-  defaultDatabaseLimits,
-  defaultDatabaseRuntimeLimits
-};

package/js/chunk-DHUDODG5.js

@@ -1,213 +0,0 @@
-import {
-  parseDatabaseSchema,
-  promiseTable
-} from "./chunk-PLCMJREA.js";
-import {
-  fromPromise,
-  nativeOperation
-} from "./chunk-PYUYJRSK.js";
-import {
-  ScheduleTiming
-} from "./chunk-3M2MEDNL.js";
-import {
-  decoderOf,
-  isSchema,
-  storageFieldOf
-} from "./chunk-WFSQXYUT.js";
-import {
-  AppStorageUnavailable
-} from "./chunk-FZJOYIZO.js";
-import {
-  JsonValue
-} from "./chunk-SATWJKN6.js";
-import {
-  Effect_exports,
-  Schema_exports
-} from "./chunk-FW5HBOIK.js";
-
-// src/implementation/workflows.ts
-var NativeWorkflow = /* @__PURE__ */ Symbol("apps.Workflow");
-var workflow = (options, run) => ({
-  [NativeWorkflow]: {
-    input: decoderOf(options.input),
-    ...options.output === void 0 ? {} : { output: decoderOf(options.output) },
-    ...options.description === void 0 ? {} : { description: options.description },
-    run: (context, input) => Effect_exports.tryPromise({
-      // SAFETY: defineApp checks required context; the host supplies the pinned run's capabilities.
-      try: () => run(context, input),
-      catch: (error) => error
-    })
-  }
-});
-var nativeWorkflow = (value) => {
-  if (typeof value !== "object" || value === null || !(NativeWorkflow in value)) return void 0;
-  return value[NativeWorkflow];
-};
-
-// src/implementation/app.ts
-var InternalApp = /* @__PURE__ */ Symbol("apps.App");
-var isApp = (value) => typeof value === "object" && value !== null && InternalApp in value;
-var toEffectApp = (app) => app[InternalApp];
-function adaptDefinition(definition) {
-  if ("tools" in definition) throw new Error("Use queries and mutations instead of tools");
-  const webhooks = definition.webhooks === void 0 ? {} : {
-    webhooks: Object.fromEntries(
-      Object.entries(definition.webhooks).map(([name, webhook]) => [
-        name,
-        {
-          ...webhook,
-          ...webhook.register === void 0 ? {} : { register: fromPromise(webhook.register) },
-          handle: fromPromise(webhook.handle),
-          ...webhook.unregister === void 0 ? {} : { unregister: fromPromise(webhook.unregister) },
-          ..."config" in webhook && isSchema(webhook.config) ? { config: decoderOf(webhook.config) } : {},
-          ..."state" in webhook && isSchema(webhook.state) ? { state: decoderOf(webhook.state) } : {}
-        }
-      ])
-    )
-  };
-  const operations = (kind, catalog) => Object.fromEntries(
-    Object.entries(catalog).map(([name, value]) => {
-      const operation = nativeOperation(value);
-      if (operation === void 0 || operation.kind !== kind)
-        throw new Error("Invalid app data operation");
-      return [name, operation];
-    })
-  );
-  const workflows = definition.workflows === void 0 ? {} : {
-    workflows: Object.fromEntries(
-      Object.entries(definition.workflows).map(([name, value]) => {
-        const declared = nativeWorkflow(value);
-        if (declared === void 0) throw new Error("Invalid workflow declaration");
-        return [name, declared];
-      })
-    )
-  };
-  const data = {
-    ...definition.queries === void 0 ? {} : { queries: operations("query", definition.queries) },
-    ...definition.mutations === void 0 ? {} : { mutations: operations("mutation", definition.mutations) }
-  };
-  const schedules = definition.schedules === void 0 ? {} : {
-    schedules: Object.fromEntries(
-      Object.entries(definition.schedules).map(([name, schedule]) => {
-        const matches = Object.entries(definition.mutations ?? {}).filter(
-          ([, operation]) => operation === schedule.operation
-        );
-        const match = matches[0];
-        if (match === void 0 || matches.length !== 1)
-          throw new Error("A schedule must reference exactly one named mutation in this app");
-        return [
-          name,
-          {
-            timing: Schema_exports.decodeUnknownSync(ScheduleTiming)(schedule.timing),
-            input: Schema_exports.decodeUnknownSync(JsonValue)(schedule.input),
-            tool: `mutations.${match[0]}`
-          }
-        ];
-      })
-    )
-  };
-  return {
-    ...definition,
-    ...webhooks,
-    ...workflows,
-    ...data,
-    ...schedules
-  };
-}
-var defineApp = (requirements, definition) => {
-  const evaluate = typeof definition === "function" ? definition : async () => definition;
-  const factory = fromPromise(evaluate);
-  const native = {
-    accounts: requirements.accounts,
-    ...requirements.database === void 0 ? {} : { database: requirements.database },
-    evaluate: (context) => factory(context).pipe(Effect_exports.map((value) => adaptDefinition(value)))
-  };
-  return {
-    [InternalApp]: native,
-    accounts: native.accounts,
-    evaluate: (context) => Effect_exports.runPromise(factory(context))
-  };
-};
-
-// src/implementation/storage.ts
-var table = (fields) => tableWithIndexes(fields, []);
-var tableWithIndexes = (fields, indexes) => ({
-  fields,
-  indexes,
-  index: (name, fieldsInIndex) => tableWithIndexes(fields, [...indexes, { name, fields: fieldsInIndex }])
-});
-var serialize = (tables) => {
-  const definitions = Object.fromEntries(
-    Object.entries(tables).map(([name, table2]) => [
-      name,
-      {
-        fields: Object.fromEntries(
-          Object.entries(table2.fields).map(([fieldName, schema]) => {
-            const field = storageFieldOf(schema);
-            if (field === void 0) throw new Error("Database columns must use a scalar schema");
-            return [fieldName, field];
-          })
-        ),
-        indexes: table2.indexes
-      }
-    ])
-  );
-  return Effect_exports.runSync(parseDatabaseSchema(definitions));
-};
-var authorDatabase = (tables, session, signal, writable) => {
-  return Object.fromEntries(
-    Object.entries(tables).map(([name, table2]) => {
-      const api = promiseTable(session, name, signal);
-      const parseFields = (input, partial) => {
-        const values = Schema_exports.decodeUnknownSync(
-          Schema_exports.Record(Schema_exports.String, Schema_exports.Unknown)
-        )(input);
-        const fields = {};
-        for (const [key, value] of Object.entries(values)) {
-          if (value === void 0) continue;
-          const field = Object.hasOwn(table2.fields, key) ? table2.fields[key] : void 0;
-          if (field === void 0) throw new Error("Unknown database column");
-          const definition = storageFieldOf(field);
-          fields[key] = value === null && definition?.optional ? null : field.parse(value);
-        }
-        if (!partial) {
-          for (const [key, field] of Object.entries(table2.fields))
-            if (!Object.hasOwn(fields, key)) {
-              const value = field.parse(void 0);
-              if (value !== void 0) fields[key] = value;
-            }
-        }
-        return fields;
-      };
-      const read = { get: api.get, withIndex: api.withIndex };
-      return [
-        name,
-        writable ? {
-          ...read,
-          insert: (value) => api.insert(parseFields(value, false)),
-          update: (id, value) => api.update(id, parseFields(value, true)),
-          delete: api.delete
-        } : read
-      ];
-    })
-  );
-};
-var defineDatabase = (tables) => ({
-  schema: serialize(tables),
-  tables
-});
-var unavailableStorage = {
-  read: () => Effect_exports.fail(new AppStorageUnavailable()),
-  mutate: () => Effect_exports.fail(new AppStorageUnavailable())
-};
-
-export {
-  workflow,
-  isApp,
-  toEffectApp,
-  defineApp,
-  table,
-  authorDatabase,
-  defineDatabase,
-  unavailableStorage
-};

package/js/chunk-FZJOYIZO.js

@@ -1,19 +0,0 @@
-import {
-  Schema_exports
-} from "./chunk-FW5HBOIK.js";
-
-// src/contracts/storage.ts
-var StorageName = Schema_exports.NonEmptyString.check(Schema_exports.isMaxLength(200));
-var AppStorageUnavailable = class extends Schema_exports.TaggedError()(
-  "AppStorageUnavailable",
-  {}
-) {
-};
-var AppStorageError = class extends Schema_exports.TaggedError()("AppStorageError", {}) {
-};
-
-export {
-  StorageName,
-  AppStorageUnavailable,
-  AppStorageError
-};

package/js/chunk-LGIYBDWA.js

@@ -1,85 +0,0 @@
-import {
-  Schema_exports
-} from "./chunk-FW5HBOIK.js";
-
-// ../app-cache/src/contracts/cache.ts
-var CacheError = class extends Schema_exports.TaggedError()("CacheError", {
-  reason: Schema_exports.Literals(["unavailable", "storage", "invalid", "capacity", "timeout"])
-}) {
-};
-var cacheLimits = {
-  keyBytes: 8192,
-  entryBytes: 2e6,
-  batchBytes: 8e6,
-  batchEntries: 128,
-  totalBytes: 128e6,
-  totalEntries: 1e5,
-  retentionMs: 7 * 24 * 60 * 60 * 1e3,
-  loadTimeoutMs: 9e4,
-  /**
-   * A loader's lease lapses this long after its host last renewed it. Hosts renew every
-   * `renewMs` while the invocation that claimed it runs, so a stalled or lost holder frees the
-   * key well inside an MCP execute budget.
-   */
-  leaseMs: 15e3,
-  renewMs: 5e3,
-  /** The longest a caller waits on another loader before loading for itself without publishing. */
-  waitMs: 1e4,
-  /** Bound for one command to a host store; a lost reply fails instead of holding its caller. */
-  commandTimeoutMs: 1e4
-};
-var Key = Schema_exports.String.check(Schema_exports.isPattern(/^[a-f0-9]{64}$/));
-var Time = Schema_exports.Finite.check(Schema_exports.isGreaterThanOrEqualTo(0));
-var CacheEntry = Schema_exports.Struct({
-  value: Schema_exports.Json,
-  version: Schema_exports.String,
-  freshUntil: Time,
-  staleUntil: Time
-});
-var CacheAcquired = Schema_exports.Struct({
-  entry: Schema_exports.NullOr(CacheEntry),
-  lease: Schema_exports.NullOr(Schema_exports.String)
-});
-var CacheCommand = Schema_exports.Union([
-  Schema_exports.Struct({ operation: Schema_exports.Literal("read"), keys: Schema_exports.Array(Key) }),
-  Schema_exports.Struct({
-    operation: Schema_exports.Literal("acquire"),
-    key: Key,
-    /** Claim even a fresh entry, as an explicit refresh does. */
-    refresh: Schema_exports.Boolean,
-    /** Claim only while the entry still has this version. Absent accepts the current one. */
-    version: Schema_exports.optionalKey(Schema_exports.NullOr(Schema_exports.String))
-  }),
-  Schema_exports.Struct({
-    operation: Schema_exports.Literal("claim"),
-    key: Key,
-    version: Schema_exports.NullOr(Schema_exports.String)
-  }),
-  Schema_exports.Struct({
-    operation: Schema_exports.Literal("publish"),
-    key: Key,
-    lease: Schema_exports.String,
-    entry: CacheEntry
-  }),
-  Schema_exports.Struct({ operation: Schema_exports.Literal("release"), key: Key, lease: Schema_exports.String }),
-  /** Extend a lease its holder still owns. Replies false once the lease lapsed or was replaced. */
-  Schema_exports.Struct({ operation: Schema_exports.Literal("renew"), key: Key, lease: Schema_exports.String }),
-  Schema_exports.Struct({
-    operation: Schema_exports.Literal("write"),
-    entries: Schema_exports.Array(Schema_exports.Struct({ key: Key, entry: CacheEntry }))
-  }),
-  Schema_exports.Struct({ operation: Schema_exports.Literal("invalidate"), key: Key })
-]);
-var CacheReply = Schema_exports.Union([
-  Schema_exports.Struct({ ok: Schema_exports.Literal(true), value: Schema_exports.Json }),
-  Schema_exports.Struct({ ok: Schema_exports.Literal(false), error: CacheError })
-]);
-
-export {
-  CacheError,
-  cacheLimits,
-  CacheEntry,
-  CacheAcquired,
-  CacheCommand,
-  CacheReply
-};