@hachej/boring-ask-user 0.1.13

package/dist/shared/index.js

@@ -0,0 +1,305 @@
+// src/shared/constants.ts
+var ASK_USER_PLUGIN_ID = "ask-user";
+var ASK_USER_PANEL_ID = "ask-user.questions";
+var ASK_USER_PANEL_TITLE = "Questions";
+var ASK_USER_SURFACE_KIND = "questions";
+var ASK_USER_COMMAND_KINDS = {
+  SUBMIT: "questions.submit",
+  CANCEL: "questions.cancel"
+};
+var ASK_USER_UI_STATE_SLOTS = {
+  PENDING: "questions.pending"
+};
+var ASK_USER_SCHEMA_LIMITS = {
+  maxFields: 8,
+  maxOptionsPerField: 50,
+  maxFieldNameLength: 64,
+  maxTitleLength: 200,
+  maxLabelLength: 160,
+  maxHelpTextLength: 500,
+  maxContextLength: 4e3,
+  maxSerializedSchemaBytes: 32e3,
+  maxFreeformAnswerLength: 4e3,
+  minTimeoutMs: 1e3,
+  maxTimeoutMs: 30 * 6e4,
+  defaultTimeoutMs: 10 * 6e4
+};
+var ASK_USER_FIELD_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
+var ASK_USER_RESERVED_FIELD_NAMES = /* @__PURE__ */ new Set([
+  "__proto__",
+  "prototype",
+  "constructor"
+]);
+
+// src/shared/error-codes.ts
+var ASK_USER_ERROR_CODES = {
+  PENDING_EXISTS: "ASK_USER_PENDING_EXISTS",
+  QUESTION_NOT_FOUND: "ASK_USER_QUESTION_NOT_FOUND",
+  QUESTION_ABANDONED: "ASK_USER_QUESTION_ABANDONED",
+  QUESTION_NOT_READY: "ASK_USER_QUESTION_NOT_READY",
+  SCHEMA_INVALID: "ASK_USER_SCHEMA_INVALID",
+  ANSWER_INVALID: "ASK_USER_ANSWER_INVALID",
+  SESSION_MISMATCH: "ASK_USER_SESSION_MISMATCH",
+  UI_UNAVAILABLE: "ASK_USER_UI_UNAVAILABLE",
+  ALREADY_ANSWERED: "ASK_USER_ALREADY_ANSWERED",
+  ALREADY_CANCELLED: "ASK_USER_ALREADY_CANCELLED",
+  UNAUTHORIZED: "ASK_USER_UNAUTHORIZED",
+  UI_ACK_TIMEOUT: "ASK_USER_UI_ACK_TIMEOUT",
+  RATE_LIMITED: "ASK_USER_RATE_LIMITED",
+  RUNTIME_UNAVAILABLE: "ASK_USER_RUNTIME_UNAVAILABLE"
+};
+var ASK_USER_ERROR_CODE_VALUES = Object.values(ASK_USER_ERROR_CODES);
+
+// src/shared/schema.ts
+import { z } from "zod";
+var isoStringSchema = z.string().min(1);
+var fieldNameSchema = z.string().regex(ASK_USER_FIELD_NAME_PATTERN, "field name must match ^[A-Za-z][A-Za-z0-9_-]{0,63}$").refine((name) => !ASK_USER_RESERVED_FIELD_NAMES.has(name), "field name is reserved");
+var boundedString = (max) => z.string().max(max);
+var optionalBoundedString = (max) => boundedString(max).optional();
+var askUserOptionSchema = z.object({
+  value: z.string().min(1).max(ASK_USER_SCHEMA_LIMITS.maxLabelLength),
+  label: boundedString(ASK_USER_SCHEMA_LIMITS.maxLabelLength),
+  description: optionalBoundedString(ASK_USER_SCHEMA_LIMITS.maxHelpTextLength)
+}).strict();
+var baseFieldSchema = {
+  name: fieldNameSchema,
+  label: boundedString(ASK_USER_SCHEMA_LIMITS.maxLabelLength),
+  required: z.boolean().optional(),
+  helpText: optionalBoundedString(ASK_USER_SCHEMA_LIMITS.maxHelpTextLength)
+};
+function safePattern(pattern) {
+  try {
+    if (/\\[1-9]/.test(pattern)) return false;
+    if (/\(\?([=!<]|<=|<!)/.test(pattern)) return false;
+    new RegExp(pattern);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var textFieldSchema = z.object({
+  type: z.literal("text"),
+  ...baseFieldSchema,
+  placeholder: optionalBoundedString(ASK_USER_SCHEMA_LIMITS.maxLabelLength),
+  defaultValue: optionalBoundedString(ASK_USER_SCHEMA_LIMITS.maxFreeformAnswerLength),
+  minLength: z.number().int().min(0).max(ASK_USER_SCHEMA_LIMITS.maxFreeformAnswerLength).optional(),
+  maxLength: z.number().int().min(0).max(ASK_USER_SCHEMA_LIMITS.maxFreeformAnswerLength).optional(),
+  pattern: z.string().max(512).refine(safePattern, "pattern must be safe and valid").optional()
+}).strict().superRefine((field, ctx) => {
+  if (field.minLength !== void 0 && field.maxLength !== void 0 && field.minLength > field.maxLength) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["minLength"], message: "minLength must be <= maxLength" });
+  }
+  if (field.defaultValue !== void 0) {
+    if (field.minLength !== void 0 && field.defaultValue.length < field.minLength) {
+      ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["defaultValue"], message: "defaultValue shorter than minLength" });
+    }
+    if (field.maxLength !== void 0 && field.defaultValue.length > field.maxLength) {
+      ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["defaultValue"], message: "defaultValue longer than maxLength" });
+    }
+  }
+});
+var textareaFieldSchema = z.object({
+  type: z.literal("textarea"),
+  ...baseFieldSchema,
+  placeholder: optionalBoundedString(ASK_USER_SCHEMA_LIMITS.maxLabelLength),
+  defaultValue: optionalBoundedString(ASK_USER_SCHEMA_LIMITS.maxFreeformAnswerLength),
+  minLength: z.number().int().min(0).max(ASK_USER_SCHEMA_LIMITS.maxFreeformAnswerLength).optional(),
+  maxLength: z.number().int().min(0).max(ASK_USER_SCHEMA_LIMITS.maxFreeformAnswerLength).optional()
+}).strict().superRefine((field, ctx) => {
+  if (field.minLength !== void 0 && field.maxLength !== void 0 && field.minLength > field.maxLength) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["minLength"], message: "minLength must be <= maxLength" });
+  }
+});
+function optionsRefinement(field, ctx) {
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < field.options.length; i++) {
+    const value = field.options[i]?.value;
+    if (seen.has(value)) {
+      ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["options", i, "value"], message: "duplicate option value" });
+    }
+    seen.add(value);
+  }
+  if (field.defaultValue !== void 0 && !seen.has(field.defaultValue)) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["defaultValue"], message: "defaultValue must reference an option value" });
+  }
+}
+var selectFieldSchema = z.object({
+  type: z.literal("select"),
+  ...baseFieldSchema,
+  options: z.array(askUserOptionSchema).min(2).max(ASK_USER_SCHEMA_LIMITS.maxOptionsPerField),
+  defaultValue: z.string().optional()
+}).strict().superRefine(optionsRefinement);
+var radioFieldSchema = z.object({
+  type: z.literal("radio"),
+  ...baseFieldSchema,
+  options: z.array(askUserOptionSchema).min(2).max(ASK_USER_SCHEMA_LIMITS.maxOptionsPerField),
+  defaultValue: z.string().optional()
+}).strict().superRefine(optionsRefinement);
+var multiselectFieldSchema = z.object({
+  type: z.literal("multiselect"),
+  ...baseFieldSchema,
+  options: z.array(askUserOptionSchema).min(1).max(ASK_USER_SCHEMA_LIMITS.maxOptionsPerField),
+  defaultValue: z.array(z.string()).optional(),
+  minSelections: z.number().int().min(0).optional(),
+  maxSelections: z.number().int().min(0).optional()
+}).strict().superRefine((field, ctx) => {
+  const values = /* @__PURE__ */ new Set();
+  for (let i = 0; i < field.options.length; i++) {
+    const value = field.options[i]?.value;
+    if (values.has(value)) {
+      ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["options", i, "value"], message: "duplicate option value" });
+    }
+    values.add(value);
+  }
+  if (field.defaultValue) {
+    for (const value of field.defaultValue) {
+      if (!values.has(value)) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["defaultValue"], message: "defaultValue must reference option values" });
+      }
+    }
+  }
+  if (field.minSelections !== void 0 && field.maxSelections !== void 0 && field.minSelections > field.maxSelections) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["minSelections"], message: "minSelections must be <= maxSelections" });
+  }
+  if (field.maxSelections !== void 0 && field.maxSelections > field.options.length) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["maxSelections"], message: "maxSelections must be <= options.length" });
+  }
+});
+var checkboxFieldSchema = z.object({
+  type: z.literal("checkbox"),
+  name: fieldNameSchema,
+  label: boundedString(ASK_USER_SCHEMA_LIMITS.maxLabelLength),
+  defaultValue: z.boolean().optional(),
+  helpText: optionalBoundedString(ASK_USER_SCHEMA_LIMITS.maxHelpTextLength)
+}).strict();
+var numberFieldSchema = z.object({
+  type: z.literal("number"),
+  ...baseFieldSchema,
+  defaultValue: z.number().finite().optional(),
+  placeholder: optionalBoundedString(ASK_USER_SCHEMA_LIMITS.maxLabelLength),
+  min: z.number().finite().optional(),
+  max: z.number().finite().optional(),
+  step: z.number().finite().positive().optional(),
+  integer: z.boolean().optional()
+}).strict().superRefine((field, ctx) => {
+  if (field.min !== void 0 && field.max !== void 0 && field.min > field.max) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["min"], message: "min must be <= max" });
+  }
+  if (field.defaultValue !== void 0) {
+    if (field.integer && !Number.isInteger(field.defaultValue)) {
+      ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["defaultValue"], message: "defaultValue must be an integer" });
+    }
+    if (field.min !== void 0 && field.defaultValue < field.min) {
+      ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["defaultValue"], message: "defaultValue must be >= min" });
+    }
+    if (field.max !== void 0 && field.defaultValue > field.max) {
+      ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["defaultValue"], message: "defaultValue must be <= max" });
+    }
+  }
+});
+var AskUserFieldSchema = z.union([
+  textFieldSchema,
+  textareaFieldSchema,
+  selectFieldSchema,
+  multiselectFieldSchema,
+  checkboxFieldSchema,
+  radioFieldSchema,
+  numberFieldSchema
+]);
+var AskUserFormSchemaSchema = z.object({
+  wireVersion: z.literal(1),
+  fields: z.array(AskUserFieldSchema).min(1).max(ASK_USER_SCHEMA_LIMITS.maxFields),
+  submitLabel: optionalBoundedString(ASK_USER_SCHEMA_LIMITS.maxLabelLength)
+}).strict().superRefine((schema, ctx) => {
+  const names = /* @__PURE__ */ new Set();
+  for (let i = 0; i < schema.fields.length; i++) {
+    const name = schema.fields[i]?.name;
+    if (names.has(name)) {
+      ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["fields", i, "name"], message: "duplicate field name" });
+    }
+    names.add(name);
+  }
+  if (serializedSize(schema) > ASK_USER_SCHEMA_LIMITS.maxSerializedSchemaBytes) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, message: "schema exceeds max serialized size" });
+  }
+});
+var AskUserToolInputSchema = z.object({
+  title: boundedString(ASK_USER_SCHEMA_LIMITS.maxTitleLength).min(1),
+  context: optionalBoundedString(ASK_USER_SCHEMA_LIMITS.maxContextLength),
+  schema: AskUserFormSchemaSchema,
+  timeoutMs: z.number().int().min(ASK_USER_SCHEMA_LIMITS.minTimeoutMs).max(ASK_USER_SCHEMA_LIMITS.maxTimeoutMs).optional()
+}).strict();
+var AskUserRequestSchema = z.object({
+  sessionId: z.string().min(1),
+  title: boundedString(ASK_USER_SCHEMA_LIMITS.maxTitleLength).optional(),
+  context: optionalBoundedString(ASK_USER_SCHEMA_LIMITS.maxContextLength),
+  schema: AskUserFormSchemaSchema.optional(),
+  timeoutMs: z.number().int().min(ASK_USER_SCHEMA_LIMITS.minTimeoutMs).max(ASK_USER_SCHEMA_LIMITS.maxTimeoutMs).optional()
+}).strict();
+var AskUserAnswerValueSchema = z.union([
+  z.string().max(ASK_USER_SCHEMA_LIMITS.maxFreeformAnswerLength),
+  z.array(z.string()).max(ASK_USER_SCHEMA_LIMITS.maxOptionsPerField),
+  z.boolean(),
+  z.number().finite(),
+  z.null()
+]);
+var AskUserAnswerSchema = z.object({
+  questionId: z.string().min(1),
+  sessionId: z.string().min(1),
+  values: z.record(fieldNameSchema, AskUserAnswerValueSchema),
+  submittedAt: isoStringSchema
+}).strict();
+var commandParamsBase = {
+  questionId: z.string().min(1),
+  sessionId: z.string().min(1)
+};
+var QuestionsSubmitCommandSchema = z.object({
+  kind: z.literal(ASK_USER_COMMAND_KINDS.SUBMIT),
+  params: z.object({
+    ...commandParamsBase,
+    answerToken: z.string().min(1),
+    values: z.record(fieldNameSchema, AskUserAnswerValueSchema)
+  }).strict()
+}).strict();
+var QuestionsCancelCommandSchema = z.object({
+  kind: z.literal(ASK_USER_COMMAND_KINDS.CANCEL),
+  params: z.object({ ...commandParamsBase, answerToken: z.string().min(1) }).strict()
+}).strict();
+var QuestionsCommandSchema = z.discriminatedUnion("kind", [
+  QuestionsSubmitCommandSchema,
+  QuestionsCancelCommandSchema
+]);
+function serializedSize(value) {
+  return new TextEncoder().encode(JSON.stringify(value)).length;
+}
+function validateAskUserFormSchema(value) {
+  return AskUserFormSchemaSchema.safeParse(value);
+}
+function validateAskUserToolInput(value) {
+  return AskUserToolInputSchema.safeParse(value);
+}
+export {
+  ASK_USER_COMMAND_KINDS,
+  ASK_USER_ERROR_CODES,
+  ASK_USER_ERROR_CODE_VALUES,
+  ASK_USER_FIELD_NAME_PATTERN,
+  ASK_USER_PANEL_ID,
+  ASK_USER_PANEL_TITLE,
+  ASK_USER_PLUGIN_ID,
+  ASK_USER_RESERVED_FIELD_NAMES,
+  ASK_USER_SCHEMA_LIMITS,
+  ASK_USER_SURFACE_KIND,
+  ASK_USER_UI_STATE_SLOTS,
+  AskUserAnswerSchema,
+  AskUserAnswerValueSchema,
+  AskUserFieldSchema,
+  AskUserFormSchemaSchema,
+  AskUserRequestSchema,
+  AskUserToolInputSchema,
+  QuestionsCancelCommandSchema,
+  QuestionsCommandSchema,
+  QuestionsSubmitCommandSchema,
+  serializedSize,
+  validateAskUserFormSchema,
+  validateAskUserToolInput
+};

package/dist/types-CF72YmK-.d.ts

@@ -0,0 +1,193 @@
+declare const ASK_USER_PLUGIN_ID: "ask-user";
+declare const ASK_USER_PANEL_ID: "ask-user.questions";
+declare const ASK_USER_PANEL_TITLE: "Questions";
+declare const ASK_USER_SURFACE_KIND: "questions";
+declare const ASK_USER_COMMAND_KINDS: {
+    readonly SUBMIT: "questions.submit";
+    readonly CANCEL: "questions.cancel";
+};
+declare const ASK_USER_UI_STATE_SLOTS: {
+    readonly PENDING: "questions.pending";
+};
+declare const ASK_USER_SCHEMA_LIMITS: {
+    readonly maxFields: 8;
+    readonly maxOptionsPerField: 50;
+    readonly maxFieldNameLength: 64;
+    readonly maxTitleLength: 200;
+    readonly maxLabelLength: 160;
+    readonly maxHelpTextLength: 500;
+    readonly maxContextLength: 4000;
+    readonly maxSerializedSchemaBytes: 32000;
+    readonly maxFreeformAnswerLength: 4000;
+    readonly minTimeoutMs: 1000;
+    readonly maxTimeoutMs: number;
+    readonly defaultTimeoutMs: number;
+};
+declare const ASK_USER_FIELD_NAME_PATTERN: RegExp;
+declare const ASK_USER_RESERVED_FIELD_NAMES: Set<string>;
+
+type AskUserOption = {
+    value: string;
+    label: string;
+    description?: string;
+};
+type AskUserField = {
+    type: "text";
+    name: string;
+    label: string;
+    required?: boolean;
+    placeholder?: string;
+    defaultValue?: string;
+    helpText?: string;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+} | {
+    type: "textarea";
+    name: string;
+    label: string;
+    required?: boolean;
+    placeholder?: string;
+    defaultValue?: string;
+    helpText?: string;
+    minLength?: number;
+    maxLength?: number;
+} | {
+    type: "select";
+    name: string;
+    label: string;
+    required?: boolean;
+    options: AskUserOption[];
+    defaultValue?: string;
+    helpText?: string;
+} | {
+    type: "multiselect";
+    name: string;
+    label: string;
+    required?: boolean;
+    options: AskUserOption[];
+    defaultValue?: string[];
+    helpText?: string;
+    minSelections?: number;
+    maxSelections?: number;
+} | {
+    type: "checkbox";
+    name: string;
+    label: string;
+    defaultValue?: boolean;
+    helpText?: string;
+} | {
+    type: "radio";
+    name: string;
+    label: string;
+    required?: boolean;
+    options: AskUserOption[];
+    defaultValue?: string;
+    helpText?: string;
+} | {
+    type: "number";
+    name: string;
+    label: string;
+    required?: boolean;
+    defaultValue?: number;
+    placeholder?: string;
+    helpText?: string;
+    min?: number;
+    max?: number;
+    step?: number;
+    integer?: boolean;
+};
+type AskUserFormSchema = {
+    wireVersion: 1;
+    fields: AskUserField[];
+    submitLabel?: string;
+};
+type AskUserRequest = {
+    sessionId: string;
+    title?: string;
+    context?: string;
+    schema?: AskUserFormSchema;
+    timeoutMs?: number;
+};
+type AskUserToolInput = {
+    title: string;
+    context?: string;
+    schema: AskUserFormSchema;
+    timeoutMs?: number;
+};
+type AskUserQuestionStatus = "ready" | "answered" | "cancelled" | "abandoned";
+type AskUserQuestion = {
+    questionId: string;
+    sessionId: string;
+    ownerPrincipalId: string;
+    status: AskUserQuestionStatus;
+    title?: string;
+    context?: string;
+    schema?: AskUserFormSchema;
+    answerToken: string;
+    createdAt: string;
+    updatedAt: string;
+};
+type AskUserAnswerValue = string | string[] | boolean | number | null;
+type AskUserAnswer = {
+    questionId: string;
+    sessionId: string;
+    values: Record<string, AskUserAnswerValue>;
+    submittedAt: string;
+};
+type AskUserCancelReason = "user_cancelled" | "timeout" | "aborted" | "ui_unavailable" | "abandoned" | "rate_limited" | "runtime_unavailable";
+type AskUserToolResult = {
+    status: "answered";
+    answer: AskUserAnswer;
+} | {
+    status: "cancelled";
+    questionId: string;
+    sessionId: string;
+    reason: AskUserCancelReason;
+};
+type QuestionsSubmitCommand = {
+    kind: typeof ASK_USER_COMMAND_KINDS.SUBMIT;
+    params: {
+        questionId: string;
+        sessionId: string;
+        answerToken: string;
+        values: Record<string, AskUserAnswerValue>;
+    };
+};
+type QuestionsCancelCommand = {
+    kind: typeof ASK_USER_COMMAND_KINDS.CANCEL;
+    params: {
+        questionId: string;
+        sessionId: string;
+        answerToken: string;
+    };
+};
+type QuestionsCommand = QuestionsSubmitCommand | QuestionsCancelCommand;
+type AskUserTranscriptEvent = {
+    type: "created";
+    question: AskUserQuestion;
+    at: string;
+} | {
+    type: "ready";
+    questionId: string;
+    sessionId: string;
+    schema: AskUserFormSchema;
+    at: string;
+} | {
+    type: "answered";
+    answer: AskUserAnswer;
+    at: string;
+} | {
+    type: "cancelled";
+    questionId: string;
+    sessionId: string;
+    reason: AskUserCancelReason;
+    at: string;
+} | {
+    type: "abandoned";
+    questionId: string;
+    sessionId: string;
+    at: string;
+};
+
+export { type AskUserQuestion as A, type QuestionsCommand as Q, type AskUserAnswer as a, type AskUserTranscriptEvent as b, type AskUserToolResult as c, type AskUserCancelReason as d, type AskUserRequest as e, type AskUserField as f, type AskUserAnswerValue as g, ASK_USER_PLUGIN_ID as h, ASK_USER_COMMAND_KINDS as i, ASK_USER_FIELD_NAME_PATTERN as j, ASK_USER_PANEL_ID as k, ASK_USER_PANEL_TITLE as l, ASK_USER_RESERVED_FIELD_NAMES as m, ASK_USER_SCHEMA_LIMITS as n, ASK_USER_SURFACE_KIND as o, ASK_USER_UI_STATE_SLOTS as p, type AskUserFormSchema as q, type AskUserOption as r, type AskUserQuestionStatus as s, type AskUserToolInput as t, type QuestionsCancelCommand as u, type QuestionsSubmitCommand as v };

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@hachej/boring-ask-user",
+  "version": "0.1.13",
+  "type": "module",
+  "private": false,
+  "description": "Ask-user plugin for Boring workspace — surfaces agent questions to the user and streams answers back.",
+  "boring": {
+    "id": "ask-user",
+    "label": "Questions",
+    "front": "dist/front/index.js",
+    "server": "dist/server/index.js"
+  },
+  "pi": {
+    "systemPrompt": "Use the ask-user tool when you need a decision, confirmation, or freeform input from the user before continuing. The user answers via the Questions panel and the tool resolves with their response."
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/front/index.d.ts",
+      "import": "./dist/front/index.js"
+    },
+    "./front": {
+      "types": "./dist/front/index.d.ts",
+      "import": "./dist/front/index.js"
+    },
+    "./server": {
+      "types": "./dist/server/index.d.ts",
+      "import": "./dist/server/index.js"
+    },
+    "./shared": {
+      "types": "./dist/shared/index.d.ts",
+      "import": "./dist/shared/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "scripts": {
+    "build": "pnpm --filter @hachej/boring-ui-kit build && pnpm --filter @hachej/boring-workspace build && tsup",
+    "typecheck": "pnpm --filter @hachej/boring-ui-kit build && pnpm --filter @hachej/boring-workspace build && tsc --noEmit",
+    "test": "pnpm --filter @hachej/boring-ui-kit build && vitest run",
+    "lint": "pnpm run typecheck",
+    "clean": "rm -rf dist .tsbuildinfo"
+  },
+  "peerDependencies": {
+    "@hachej/boring-workspace": "workspace:*",
+    "react": "^18.0.0 || ^19.0.0",
+    "react-dom": "^18.0.0 || ^19.0.0"
+  },
+  "dependencies": {
+    "@hachej/boring-ui-kit": "workspace:*",
+    "fastify": "^5.3.3",
+    "lucide-react": "^1.8.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@hachej/boring-workspace": "workspace:*",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.0",
+    "@types/node": "^22.0.0",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "@vitejs/plugin-react": "^4.0.0",
+    "jsdom": "^29.0.2",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "tsup": "^8.4.0",
+    "typescript": "~5.9.3",
+    "vitest": "^3.1.3"
+  }
+}