apps 0.0.1-beta.0 → 0.0.1-beta.2

package/js/chunk-W7D7WVSY.js

@@ -0,0 +1,18 @@
+import {
+  AccountId
+} from "./chunk-SATWJKN6.js";
+import {
+  Schema_exports
+} from "./chunk-FW5HBOIK.js";
+
+// src/contracts/provider-error.ts
+var ProviderError = class extends Schema_exports.TaggedError()("ProviderError", {
+  reason: Schema_exports.Literals(["unauthorized", "forbidden", "rate_limited", "unavailable", "rejected"]),
+  status: Schema_exports.optional(Schema_exports.Int.check(Schema_exports.isBetween({ minimum: 100, maximum: 599 }))),
+  accountId: Schema_exports.optional(AccountId)
+}) {
+};
+
+export {
+  ProviderError
+};

package/js/{chunk-BPEFS4YF.js → chunk-WFSQXYUT.js}

@@ -1,12 +1,15 @@
 import {
   ValidationError
-} from "./chunk-36DNRFZQ.js";
+} from "./chunk-SATWJKN6.js";
 import {
+  Cause_exports,
   Effect_exports,
+  Exit_exports,
+  SchemaGetter_exports,
   SchemaIssue_exports,
   SchemaParser_exports,
   Schema_exports
-} from "./chunk-2OTCEKL2.js";
+} from "./chunk-FW5HBOIK.js";
 
 // ../../node_modules/.bun/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/deep-compare-strict.js
 function deepCompareStrict(a, b) {
@@ -1129,12 +1132,30 @@ function object(fields) {
   const entries = Object.entries(fields).map(
     ([key, field]) => [key, decoderOf(field)]
   );
-  const decoder = Schema_exports.Struct(Object.fromEntries(entries));
+  const decoder = entries.length === 0 ? withJsonSchemaDocument(
+    // Native Struct({}) accepts every non-null value and retains undeclared fields.
+    Schema_exports.Record(Schema_exports.String, Schema_exports.Unknown).pipe(
+      Schema_exports.decodeTo(Schema_exports.Record(Schema_exports.String, Schema_exports.Never), {
+        decode: SchemaGetter_exports.transform(() => ({})),
+        encode: SchemaGetter_exports.transform((value) => value)
+      })
+    ),
+    { type: "object", properties: {}, additionalProperties: false }
+  ) : Schema_exports.Struct(Object.fromEntries(entries));
   return { ...wrap(decoder, false), fields: Object.freeze({ ...fields }) };
 }
 var ImportedJsonSchema = /* @__PURE__ */ Symbol("apps.JsonSchemaDocument");
 var importedJsonSchema = (decoder) => ImportedJsonSchema in decoder ? decoder[ImportedJsonSchema] : void 0;
 var withJsonSchemaDocument = (decoder, document) => Object.assign(decoder, { [ImportedJsonSchema]: document });
+var once = (compute) => {
+  let state;
+  return () => (state ??= { value: compute() }).value;
+};
+var withLazyJsonSchemaDocument = (decoder, document) => Object.defineProperty(decoder, ImportedJsonSchema, {
+  configurable: true,
+  enumerable: true,
+  get: once(document)
+});
 var nestJsonSchema = (input, pointer) => {
   const document = structuredClone(input);
   const lookup = dereference(document);
@@ -1232,6 +1253,40 @@ function interpretedDocument(value) {
   }
   return Object.fromEntries(entries);
 }
+var containerKeywords = /* @__PURE__ */ new Set([
+  "$ref",
+  "$recursiveRef",
+  "$dynamicRef",
+  "properties",
+  "patternProperties",
+  "additionalProperties",
+  "unevaluatedProperties",
+  "propertyNames",
+  "items",
+  "prefixItems",
+  "additionalItems",
+  "unevaluatedItems",
+  "contains",
+  "allOf",
+  "if",
+  "then",
+  "else",
+  "dependentSchemas"
+]);
+var jsonSchemaProblems = (errors) => {
+  const problems = errors.flatMap(({ keyword, instanceLocation, error }) => {
+    if (containerKeywords.has(keyword)) return [];
+    const path = instanceLocation.replace(/^#\/?/, "").split("/").filter((segment) => segment !== "").map((segment) => decodeURIComponent(segment).replace(/~1/g, "/").replace(/~0/g, "~")).map((segment) => /^\d+$/.test(segment) ? Number(segment) : segment);
+    const required = keyword === "required" ? /required property "([^"]*)"/.exec(error) : null;
+    const expected = keyword === "type" ? /Expected "([^.]*)"\.?$/.exec(error) : null;
+    const issue = required !== null ? { path: [...path, required[1] ?? ""], issue: "Missing key" } : {
+      path,
+      issue: expected !== null ? `Expected ${(expected[1] ?? "").replace(/"/g, "")}` : keyword === "const" || keyword === "enum" ? "Expected one of the allowed values" : `Failed the "${keyword}" constraint`
+    };
+    return [issue];
+  });
+  return problems.length === 0 ? false : problems;
+};
 var compileJsonSchemaDecoder = (document) => Effect_exports.gen(function* () {
   const validator = yield* Effect_exports.try({
     try: () => {
@@ -1266,7 +1321,8 @@ var compileJsonSchemaDecoder = (document) => Effect_exports.gen(function* () {
     Schema_exports.makeFilter(
       (value) => {
         try {
-          return validator.validate(value).valid;
+          const result = validator.validate(value);
+          return result.valid || jsonSchemaProblems(result.errors);
         } catch {
           return false;
         }
@@ -1276,24 +1332,58 @@ var compileJsonSchemaDecoder = (document) => Effect_exports.gen(function* () {
   );
   return Object.assign(decoder, { [ImportedJsonSchema]: document });
 });
-var jsonSchemaDecoder = (input) => Effect_exports.gen(function* () {
-  const document = yield* parse(
-    Schema_exports.Record(Schema_exports.String, Schema_exports.Json),
-    input
+var lazyDecoder = (document) => {
+  const read = once(document);
+  let compiled;
+  const compile = Effect_exports.suspend(
+    () => compiled ?? compileJsonSchemaDecoder(read()).pipe(
+      // An interrupted compilation is not a result; the next decode compiles again.
+      Effect_exports.onExit(
+        (exit) => Effect_exports.sync(() => {
+          if (Exit_exports.isSuccess(exit) || !Cause_exports.hasInterrupts(exit.cause)) compiled = exit;
+        })
+      )
+    )
   );
-  const compiled = yield* Effect_exports.cached(compileJsonSchemaDecoder(document));
   const decoder = Schema_exports.declareConstructor()(
     [],
-    () => (input2, _ast, options) => compiled.pipe(
-      Effect_exports.mapError(
-        () => new SchemaIssue_exports.InvalidValue({ message: "Unsupported JSON Schema" })
-      ),
-      Effect_exports.flatMap((schema) => SchemaParser_exports.decodeUnknownEffect(schema)(input2, options))
+    () => (input, _ast, options) => compile.pipe(
+      Effect_exports.mapError(() => new SchemaIssue_exports.InvalidValue({ message: "Unsupported JSON Schema" })),
+      Effect_exports.flatMap((schema) => SchemaParser_exports.decodeUnknownEffect(schema)(input, options))
     )
   );
-  return Object.assign(decoder, { [ImportedJsonSchema]: document });
+  return withLazyJsonSchemaDocument(decoder, read);
+};
+var lazyJsonSchemaDecoder = (document) => Effect_exports.sync(() => lazyDecoder(document));
+var isJsonValue = Schema_exports.is(Schema_exports.Json);
+var jsonDocument = (input) => {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) return void 0;
+  const keys = Object.keys(input);
+  const values = keys.map((key) => Reflect.get(input, key));
+  if (!isJsonValue(values)) return void 0;
+  const document = {};
+  keys.forEach(
+    (key, index) => Object.defineProperty(document, key, {
+      value: values[index],
+      enumerable: true,
+      writable: true,
+      configurable: true
+    })
+  );
+  return document;
+};
+var jsonSchemaDecoder = (input) => Effect_exports.suspend(() => {
+  const document = jsonDocument(input);
+  return document === void 0 ? Effect_exports.fail(new ValidationError()) : lazyJsonSchemaDecoder(() => document);
 });
-var jsonSchema = (input) => wrap(Effect_exports.runSync(jsonSchemaDecoder(input)), false);
+var jsonSchema = (input) => {
+  const document = jsonDocument(input);
+  if (document === void 0) throw new ValidationError();
+  return wrap(
+    lazyDecoder(() => document),
+    false
+  );
+};
 var storageFieldOf = (schema) => schema[StorageField];
 var id = (table) => wrap(Schema_exports.NonEmptyString, false, { kind: "id", references: table });
 var userId = () => wrap(Schema_exports.NonEmptyString, false, { kind: "userId" });
@@ -1312,9 +1402,11 @@ export {
   array,
   object,
   importedJsonSchema,
-  withJsonSchemaDocument,
+  once,
+  withLazyJsonSchemaDocument,
   nestJsonSchema,
   compileJsonSchemaDecoder,
+  lazyJsonSchemaDecoder,
   jsonSchemaDecoder,
   jsonSchema,
   storageFieldOf,

package/js/chunk-YEJOQEII.js

@@ -0,0 +1,104 @@
+import {
+  Schema_exports
+} from "./chunk-FW5HBOIK.js";
+
+// src/contracts/skills.ts
+var SkillFilePath = Schema_exports.NonEmptyString.check(
+  Schema_exports.makeFilter(
+    (path) => !path.startsWith("/") && !path.includes("\\") && !path.includes("\0") && path.split("/").every((part) => part !== "" && part !== "." && part !== "..")
+  )
+);
+var SkillFile = Schema_exports.Struct({ path: SkillFilePath, content: Schema_exports.String });
+var skillFormatLimits = {
+  nameCharacters: 64,
+  descriptionCharacters: 1024,
+  compatibilityCharacters: 500
+};
+var AppSkillName = Schema_exports.NonEmptyString.check(
+  Schema_exports.makeFilter(
+    (value) => value === value.toLowerCase() && /^[\p{L}\p{N}]+(?:-[\p{L}\p{N}]+)*$/u.test(value) && [...value].length <= skillFormatLimits.nameCharacters
+  )
+);
+var AppSkillMetadata = Schema_exports.Struct({
+  name: AppSkillName,
+  description: Schema_exports.String.check(
+    Schema_exports.makeFilter(
+      (value) => value.trim().length > 0 && [...value].length <= skillFormatLimits.descriptionCharacters
+    )
+  ),
+  license: Schema_exports.optionalKey(Schema_exports.String),
+  compatibility: Schema_exports.optionalKey(
+    Schema_exports.String.check(
+      Schema_exports.makeFilter(
+        (value) => value.trim().length > 0 && [...value].length <= skillFormatLimits.compatibilityCharacters
+      )
+    )
+  ),
+  metadata: Schema_exports.optionalKey(Schema_exports.Record(Schema_exports.String, Schema_exports.String)),
+  "allowed-tools": Schema_exports.optionalKey(Schema_exports.String)
+});
+var AppSkillSource = Schema_exports.Struct({
+  ...AppSkillMetadata.fields,
+  files: Schema_exports.Array(SkillFile).check(
+    Schema_exports.makeFilter(
+      (files) => files.some((file) => file.path === "SKILL.md") && new Set(files.map((file) => file.path)).size === files.length
+    )
+  )
+});
+var SkillDefinitionInvalid = class extends Schema_exports.TaggedError()(
+  "SkillDefinitionInvalid",
+  {
+    file: SkillFilePath,
+    reason: Schema_exports.Literals([
+      "files",
+      "directory",
+      "missing-document",
+      "frontmatter",
+      "metadata",
+      "name-mismatch"
+    ])
+  },
+  { httpApiStatus: 400 }
+) {
+};
+var AppSkills = Schema_exports.Array(AppSkillSource).check(
+  Schema_exports.makeFilter((skills) => new Set(skills.map((skill) => skill.name)).size === skills.length)
+);
+var SkillServiceName = Schema_exports.String.check(
+  Schema_exports.isPattern(/^[A-Za-z0-9](?:[A-Za-z0-9 .-]{0,98}[A-Za-z0-9])?$/)
+);
+var SkillLoadFailed = class extends Schema_exports.TaggedError()("SkillLoadFailed", {
+  reason: Schema_exports.Literals([
+    "source",
+    "request",
+    "rate_limited",
+    "document",
+    "limit",
+    "changed",
+    "encoding"
+  ]),
+  // Error instances read an omitted message as "", so an empty message means none was given.
+  message: Schema_exports.optional(Schema_exports.String.check(Schema_exports.isMaxLength(500))),
+  status: Schema_exports.optional(Schema_exports.Int.check(Schema_exports.isBetween({ minimum: 100, maximum: 599 })))
+}) {
+};
+var skillLoadLimits = {
+  files: 1e3,
+  fileBytes: 2e6,
+  totalBytes: 2e7,
+  concurrency: 8
+};
+
+export {
+  SkillFilePath,
+  SkillFile,
+  skillFormatLimits,
+  AppSkillName,
+  AppSkillMetadata,
+  AppSkillSource,
+  SkillDefinitionInvalid,
+  AppSkills,
+  SkillServiceName,
+  SkillLoadFailed,
+  skillLoadLimits
+};

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

@@ -1,6 +1,6 @@
 import {
   operationDeclaration
-} from "./chunk-C24KEZXR.js";
+} from "./chunk-PYUYJRSK.js";
 
 // src/implementation/protocol-operations.ts
 var protocolOperations = (operations, kinds = {}) => {
@@ -14,11 +14,12 @@ var protocolOperations = (operations, kinds = {}) => {
       ...operation.annotations === void 0 ? {} : { annotations: operation.annotations },
       ...operation._meta === void 0 ? {} : { _meta: operation._meta },
       input: operation.input,
-      ...operation.outputSchema === void 0 ? {} : { outputSchema: operation.outputSchema },
       run: operation.run
     };
-    if (kind === "query") queries[name] = operationDeclaration({ ...native, kind });
-    else mutations[name] = operationDeclaration({ ...native, kind: "mutation" });
+    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" }));
   }
   return { queries, mutations };
 };