apps 0.0.1-beta.11 → 0.0.1-beta.110

package/js/{chunk-JU7VHODU.js → chunk-4PIQKACY.js}

@@ -1,6 +1,49 @@
 import {
+  RecordedMessage
+} from "./chunk-OWN3DP2W.js";
+import {
+  SchemaGetter_exports,
   Schema_exports
-} from "./chunk-CDL5PM2Q.js";
+} from "./chunk-ZKDXML77.js";
+
+// ../utils/src/api-error.ts
+var MessageField = Schema_exports.String.pipe(
+  Schema_exports.decodeTo(Schema_exports.optionalKey(Schema_exports.String), {
+    decode: SchemaGetter_exports.omit(),
+    encode: SchemaGetter_exports.passthrough()
+  })
+);
+function withFields(definition) {
+  const fields = definition.fields;
+  const message = definition.message;
+  const documentation = typeof message === "string" ? { description: message } : {};
+  const DefinedError = Schema_exports.Error(definition.tag)(
+    Schema_exports.TaggedStruct(definition.tag, { ...fields, message: MessageField }).annotate(
+      documentation
+    ),
+    { httpApiStatus: definition.status, ...documentation }
+  );
+  const recorded = definition.recorded ?? (typeof message === "string" ? () => message : void 0);
+  Object.defineProperties(DefinedError.prototype, {
+    message: {
+      get() {
+        return typeof message === "string" ? message : message(this);
+      }
+    },
+    ...recorded === void 0 ? {} : {
+      [RecordedMessage]: {
+        get() {
+          return recorded(this);
+        }
+      }
+    }
+  });
+  return DefinedError;
+}
+function define(definition) {
+  return "fields" in definition ? withFields(definition) : withFields({ ...definition, fields: {} });
+}
+var ApiError = { define };
 
 // src/contracts/skills.ts
 var SkillFilePath = Schema_exports.NonEmptyString.check(
@@ -45,9 +88,18 @@ var AppSkillSource = Schema_exports.Struct({
     )
   )
 });
-var SkillDefinitionInvalid = class extends Schema_exports.TaggedError()(
-  "SkillDefinitionInvalid",
-  {
+var skillDefinitionFailures = {
+  files: (file) => `The skill files of \u201C${file}\u201D are invalid: each needs a unique relative path, text content and a SKILL.md document.`,
+  directory: (file) => `\u201C${file}\u201D is not a valid skill directory. Skill directory names use lowercase letters and digits separated by single hyphens.`,
+  "missing-document": (file) => `\u201C${file}\u201D is missing.`,
+  frontmatter: (file) => `\u201C${file}\u201D must start with valid YAML frontmatter between --- lines.`,
+  metadata: (file) => `The frontmatter of \u201C${file}\u201D needs a valid name and description within the Agent Skills limits.`,
+  "name-mismatch": (file) => `The name in \u201C${file}\u201D does not match its skill directory.`
+};
+var SkillDefinitionInvalid = ApiError.define({
+  tag: "SkillDefinitionInvalid",
+  status: 400,
+  fields: {
     file: SkillFilePath,
     reason: Schema_exports.Literals([
       "files",
@@ -58,14 +110,14 @@ var SkillDefinitionInvalid = class extends Schema_exports.TaggedError()(
       "name-mismatch"
     ])
   },
-  { httpApiStatus: 400 }
-) {
-};
+  message: ({ file, reason }) => skillDefinitionFailures[reason](file),
+  recorded: ({ reason }) => `The app's skill definition is invalid (${reason})`
+});
 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])?$/)
+  Schema_exports.isPattern(/^[A-Za-z0-9](?:[A-Za-z0-9 .-]{0,98}[A-Za-z0-9])?$/u)
 );
 var SkillLoadFailed = class extends Schema_exports.TaggedError()("SkillLoadFailed", {
   reason: Schema_exports.Literals([
@@ -79,14 +131,17 @@ var SkillLoadFailed = class extends Schema_exports.TaggedError()("SkillLoadFaile
   ]),
   // 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 })))
+  status: Schema_exports.optional(Schema_exports.Int.check(Schema_exports.isBetween({ minimum: 100, maximum: 599 }))),
+  missing: Schema_exports.optional(Schema_exports.Literals(["repository", "ref"]))
 }) {
 };
 var skillLoadLimits = {
   files: 1e3,
   fileBytes: 2e6,
   totalBytes: 2e7,
-  concurrency: 8
+  concurrency: 8,
+  /** The request that checks whether a kept catalog's publication changed. */
+  checkMillis: 5e3
 };
 
 export {

package/js/{chunk-VFZKSM3T.js → chunk-4X2UI4R2.js}

@@ -1,13 +1,13 @@
 import {
   Schema_exports
-} from "./chunk-CDL5PM2Q.js";
+} from "./chunk-ZKDXML77.js";
 
 // src/contracts/ui-auth.ts
-var AppSignInId = Schema_exports.String.check(Schema_exports.isPattern(/^[a-f0-9]{64}$/)).pipe(
+var AppSignInId = Schema_exports.String.check(Schema_exports.isPattern(/^[a-f0-9]{64}$/u)).pipe(
   Schema_exports.brand("AppSignInId")
 );
 var AppSignInCode = Schema_exports.RedactedFromValue(
-  Schema_exports.String.check(Schema_exports.isPattern(/^[a-f0-9]{64}$/))
+  Schema_exports.String.check(Schema_exports.isPattern(/^[a-f0-9]{64}$/u))
 );
 var AppReturnPath = Schema_exports.String.check(
   Schema_exports.isMaxLength(8192),

package/js/{chunk-KUMBKVJD.js → chunk-62NVUKED.js}

@@ -1,9 +1,9 @@
 import {
   appSignInCallbackPath
-} from "./chunk-VFZKSM3T.js";
+} from "./chunk-4X2UI4R2.js";
 import {
   HttpServerResponse_exports
-} from "./chunk-UK573G7W.js";
+} from "./chunk-ACQXVKVQ.js";
 
 // src/implementation/ui-auth.ts
 var appPrivateHeaders = {

package/js/chunk-74H25C4X.js

@@ -0,0 +1,95 @@
+import {
+  JsonValue,
+  withLegacyKeys
+} from "./chunk-7HG422GB.js";
+import {
+  HttpApiEndpoint_exports,
+  HttpApiGroup_exports,
+  HttpApiSchema_exports,
+  HttpApi_exports
+} from "./chunk-DILSCQPJ.js";
+import {
+  Schema_exports
+} from "./chunk-ZKDXML77.js";
+
+// src/contracts/ui.ts
+var UiContextFields = Schema_exports.Struct({
+  version: Schema_exports.NonEmptyString,
+  accounts: Schema_exports.optional(
+    Schema_exports.Record(Schema_exports.NonEmptyString, Schema_exports.Array(Schema_exports.NonEmptyString))
+  )
+});
+var UiContext = UiContextFields.pipe(withLegacyKeys({ version: "deployment" }));
+var UiOperation = Schema_exports.Struct({
+  ...UiContextFields.fields,
+  name: Schema_exports.NonEmptyString,
+  input: JsonValue
+}).pipe(withLegacyKeys({ version: "deployment" }));
+var UiUnauthorized = class extends Schema_exports.TaggedError()(
+  "UiUnauthorized",
+  {},
+  { httpApiStatus: 401 }
+) {
+};
+var UiForbidden = class extends Schema_exports.TaggedError()(
+  "UiForbidden",
+  {},
+  { httpApiStatus: 403 }
+) {
+};
+var UiVersionChanged = class extends Schema_exports.TaggedError()(
+  "UiDeploymentChanged",
+  {},
+  { httpApiStatus: 409 }
+) {
+};
+var UiFailed = class extends Schema_exports.TaggedError()(
+  "UiFailed",
+  {
+    reason: Schema_exports.Literals(["unavailable", "operation_failed", "account_required"])
+  },
+  { httpApiStatus: 422 }
+) {
+};
+var UiSnapshot = Schema_exports.Union([
+  Schema_exports.Struct({
+    type: Schema_exports.Literal("snapshot"),
+    value: JsonValue,
+    trace: Schema_exports.optional(Schema_exports.Unknown)
+  }),
+  Schema_exports.Struct({ type: Schema_exports.Literal("failure"), error: UiFailed }),
+  Schema_exports.Struct({ type: Schema_exports.Literal("heartbeat") })
+]);
+var errors = [UiUnauthorized, UiForbidden, UiVersionChanged, UiFailed];
+var AppUiApi = HttpApi_exports.make("app-ui").add(
+  HttpApiGroup_exports.make("ui").add(
+    HttpApiEndpoint_exports.post("query", "/_executor/api/query", {
+      payload: UiOperation,
+      success: JsonValue,
+      error: errors
+    })
+  ).add(
+    HttpApiEndpoint_exports.post("mutate", "/_executor/api/mutate", {
+      payload: UiOperation,
+      success: JsonValue,
+      error: errors
+    })
+  ).add(
+    HttpApiEndpoint_exports.post("subscribe", "/_executor/api/subscribe", {
+      payload: UiOperation,
+      success: HttpApiSchema_exports.StreamSse({ data: UiSnapshot, error: Schema_exports.Union(errors) }),
+      error: errors
+    })
+  )
+);
+
+export {
+  UiContext,
+  UiOperation,
+  UiUnauthorized,
+  UiForbidden,
+  UiVersionChanged,
+  UiFailed,
+  UiSnapshot,
+  AppUiApi
+};

package/js/chunk-7HG422GB.js

@@ -0,0 +1,90 @@
+import {
+  SchemaTransformation_exports,
+  Schema_exports
+} from "./chunk-ZKDXML77.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.isStartingWith("acc_"), Schema_exports.isMinLength(5)),
+  Schema_exports.brand("acc")
+);
+var HttpUrl = Schema_exports.String.check(
+  Schema_exports.makeFilter((value) => {
+    try {
+      const url = new URL(value);
+      return url.protocol === "https:" || url.protocol === "http:";
+    } catch {
+      return false;
+    }
+  })
+);
+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";
+  }
+};
+
+// ../utils/src/legacy-keys.ts
+var withLegacyKeys = (mapping) => (self) => {
+  const renamed = Object.entries(mapping).filter(
+    (entry) => typeof entry[1] === "string"
+  );
+  const fields = {};
+  for (const key of Object.keys(self.fields)) {
+    const encoded = Schema_exports.toEncoded(self.fields[key]);
+    const legacy = mapping[key];
+    fields[key] = typeof legacy === "string" ? Schema_exports.optionalKey(encoded) : encoded;
+    if (typeof legacy === "string") fields[legacy] = Schema_exports.optionalKey(encoded);
+  }
+  return Schema_exports.Struct(fields).pipe(
+    Schema_exports.decodeTo(
+      self,
+      SchemaTransformation_exports.transform({
+        decode: (input) => {
+          const output = { ...input };
+          for (const [key, legacy] of renamed) {
+            if (!Object.hasOwn(output, key) && Object.hasOwn(output, legacy)) {
+              output[key] = output[legacy];
+            }
+            delete output[legacy];
+          }
+          return output;
+        },
+        encode: (input) => {
+          const output = { ...input };
+          for (const [key, legacy] of renamed) {
+            if (Object.hasOwn(output, key)) output[legacy] = output[key];
+          }
+          return output;
+        }
+      })
+    )
+  );
+};
+
+export {
+  JsonValue,
+  JsonObject,
+  AccountId,
+  HttpUrl,
+  DeclarationInvalid,
+  ValidationError,
+  withLegacyKeys
+};