@epam/ai-dial-chat-hooks 1.1.0-dev.383 → 1.1.0-dev.390

package/skill-editor.d.ts

@@ -0,0 +1,503 @@
+import { Attachment } from '@epam/ai-dial-chat-shared';
+import { Dispatch } from 'react';
+import { NotificationVariant } from '@epam/ai-dial-ui-kit';
+import { SetStateAction } from 'react';
+import { SkillEditorErrors } from '@epam/ai-dial-skill-editor';
+import { SkillEditorFileActions } from '@epam/ai-dial-skill-editor';
+import { SkillEditorValues } from '@epam/ai-dial-skill-editor';
+import { SkillFileBatchError } from '@epam/ai-dial-skill-editor';
+import { SkillFileListResponseDto } from '@epam/ai-dial-chat-api-client';
+import { SkillFileTreeNode } from '@epam/ai-dial-skill-editor';
+import { SkillFileUploadCandidate } from '@epam/ai-dial-skill-editor';
+import { SkillFileValidationResult } from '@epam/ai-dial-skill-editor';
+import { SkillUploadResponseDto } from '@epam/ai-dial-chat-api-client';
+
+/**
+ * Builds the ordered supporting-file paths and `Blob` payload
+ * `createSkill`/`updateSkill` expect from the editor's file tree and
+ * in-memory content map.
+ */
+export declare const buildSkillFilesPayload: (files: SkillFileTreeNode[], filesContent: Map<string, SkillFileContent>) => SkillFilesPayload;
+
+/**
+ * Builds `SKILL.md`'s content: a YAML frontmatter block (`name`/`description`,
+ * serialized with the `yaml` package so special characters are always
+ * correctly escaped) followed by the raw instructions body.
+ */
+export declare const buildSkillManifest: ({ name, description, instructions, }: SkillManifestValues) => string;
+
+/**
+ * Builds `SKILL.md`'s content for a create or edit submission: reassigns
+ * onto the loaded/imported frontmatter when one exists (so unrecognized
+ * fields survive), otherwise builds a fresh manifest from just `name`/
+ * `description`/`instructions`.
+ */
+export declare const buildSkillManifestForSubmit: (frontmatter: Record<string, unknown>, name: string, description: string, instructions: string) => string;
+
+/**
+ * Builds `SKILL.md`'s content for an edit save: reassigns only `name`/
+ * `description` onto the *loaded* frontmatter object (mutating a shallow
+ * copy, never the original) so unrecognized fields (e.g. `version`) survive
+ * re-serialization unchanged, then appends the (possibly edited)
+ * instructions body.
+ */
+export declare const buildSkillManifestFromFrontmatter: (baseFrontmatter: Record<string, unknown>, name: string, description: string, instructions: string) => string;
+
+/**
+ * Client-side mirror of the backend's `isValidSkillRelativePath`
+ * (`apps/chat-api/src/skills/utils/skill-path.util.ts`), used only for
+ * immediate inline feedback — the server remains authoritative and may still
+ * reject a path this function accepts.
+ */
+export declare const isValidSkillRelativePath: (relativePath: string) => boolean;
+
+/** Returns a skill relative path's final segment (its display name in the file tree). */
+export declare const nameFromPath: (path: string) => string;
+
+/**
+ * Normalizes a user-entered skill name to the DIAL naming convention
+ * (lowercase letters, digits, and hyphens; no spaces): lowercases the input,
+ * replaces every run of whitespace/invalid characters with a single hyphen,
+ * and trims leading/trailing hyphens.
+ */
+export declare const normalizeSkillName: (input: string) => string;
+
+/** A skill's `SKILL.md` split into its parsed frontmatter object and the raw instructions body. */
+export declare interface ParsedSkillManifest {
+    /** The full parsed frontmatter object, including fields this app never renders. */
+    frontmatter: Record<string, unknown>;
+    /** The instructions body following the closing `---` delimiter. */
+    instructions: string;
+}
+
+/**
+ * Parses a `SKILL.md`'s YAML frontmatter and instructions body — the inverse
+ * of `buildSkillManifest`/`buildSkillManifestFromFrontmatter`. Throws if the
+ * manifest has no `---`-delimited frontmatter block.
+ */
+export declare const parseSkillManifest: (manifestText: string) => ParsedSkillManifest;
+
+/**
+ * Splits a `SKILL.md` into its YAML frontmatter fields and its prose body.
+ *
+ * Never throws: a file with no opening fence, no closing fence, or frontmatter
+ * that fails to parse resolves to the whole input as `body` with no
+ * frontmatter fields. Parse failure is strictly weaker than fetch failure —
+ * the manifest text is still returned so the Content tab can render it.
+ */
+export declare const parseSkillManifestDocument: (raw: string) => SkillManifestDocument;
+
+/**
+ * Client-side mirror of the backend's default `SKILL_FILE_UPLOAD_MAX_BYTES`
+ * (`apps/chat-api/src/config/environment.config.ts`), used only for
+ * immediate inline feedback when a user picks a file to upload — the server
+ * remains authoritative and enforces its own configured limit regardless.
+ */
+export declare const SKILL_FILE_UPLOAD_MAX_BYTES = 1048576;
+
+/** Root manifest filename required at the top of every skill archive (mirrors `SKILL_MANIFEST_FILE` in `apps/chat-api/src/skills/utils/skill-path.util.ts`). */
+export declare const SKILL_MANIFEST_FILE = "SKILL.md";
+
+/**
+ * Client-side mirror of the backend's default `SKILL_UPLOAD_MAX_FILES`
+ * (`apps/chat-api/src/config/environment.config.ts`), used only for
+ * immediate inline feedback on the projected total file count (including the
+ * root `SKILL.md`) — the server remains authoritative regardless.
+ */
+export declare const SKILL_UPLOAD_MAX_FILES = 100;
+
+/**
+ * Client-side mirror of the backend's default `SKILL_UPLOAD_MAX_TOTAL_BYTES`
+ * (`apps/chat-api/src/config/environment.config.ts`), used only for
+ * immediate inline feedback on the projected total package size — the server
+ * remains authoritative and enforces its own configured limit regardless.
+ */
+export declare const SKILL_UPLOAD_MAX_TOTAL_BYTES = 16777216;
+
+/** Structured fields lifted from a skill manifest's frontmatter. */
+export declare interface SkillAboutDetails {
+    whenToUse?: string;
+    allowedTools?: string[];
+    bundledResources?: string[];
+    skillPrompt?: string;
+}
+
+/** Already-configured DIAL Core download operations `useSkillEditorLoad` needs. */
+export declare interface SkillEditorLoadClient {
+    /** Downloads the whole-skill ZIP archive. */
+    downloadSkill: (bucket: string, path: string) => Promise<Response>;
+    /** Downloads one file within the skill (the manifest or a supporting file). */
+    downloadSkillFile: (bucket: string, path: string, filePath: string) => Promise<Response>;
+    /** Lists the skill's files when the whole-skill ZIP route is unusable. */
+    listSkillFiles: (params: {
+        bucket: string;
+        path?: string;
+        filePath: string;
+        recursive?: boolean;
+    }) => Promise<SkillFileListResponseDto>;
+}
+
+/** Edit-mode load state for a skill-authoring form; create mode never leaves `Loaded`. */
+export declare enum SkillEditorLoadState {
+    /** The edit-mode download/parse flow is in flight. */
+    Loading = "loading",
+    /** The skill loaded successfully (or create mode, which starts here). */
+    Loaded = "loaded",
+    /** The download/parse flow failed for a reason other than 403/404. */
+    Error = "error",
+    /** The caller lacks permission to read the skill. */
+    Forbidden = "forbidden",
+    /** The skill no longer exists at the given path. */
+    NotFound = "not-found"
+}
+
+/** Already-configured DIAL Core write operations `useSkillEditorSubmit` needs. */
+export declare interface SkillEditorSubmitClient {
+    /** Creates a new skill. */
+    createSkill: (bucket: string, path: string, skillManifest: string, filePaths: string[], files: Blob[]) => Promise<SkillUploadResponseDto>;
+    /** Updates an existing skill, sending `ifMatch` as the concurrency guard. */
+    updateSkill: (bucket: string, path: string, skillManifest: string, filePaths: string[], files: Blob[], ifMatch: string) => Promise<SkillUploadResponseDto>;
+}
+
+/** Localized messages `useSkillEditorSubmit` needs. */
+export declare interface SkillEditorSubmitMessages {
+    /** Shown when a required field is empty. */
+    required: string;
+    /** Shown when the normalized skill name fails DIAL's naming rules. */
+    nameInvalid: string;
+    /** Shown when the skill name already exists (409), or defensively on an unreachable create-mode 412. */
+    nameConflict: string;
+    /** Shown when the submitted package exceeds the server's size limit (413). */
+    archiveTooLarge: string;
+    /** Shown when the backend is temporarily unavailable (503). */
+    serviceUnavailable: string;
+    /** Fallback shown for a 400 whose response body carries no message. */
+    pathInvalid: string;
+    /** Generic fallback shown for any other error status. */
+    saveError: string;
+    /** Notification title on a successful create. */
+    saveSuccessTitle: string;
+    /** Notification message on a successful create, given the created name. */
+    createSuccess: (name: string) => string;
+    /** Notification title on a successful update. */
+    updateSuccessTitle: string;
+    /** Notification message on a successful update, given the skill's name. */
+    updateSuccess: (name: string) => string;
+    /** Shown when a save hits a stale-ETag conflict (412) in edit mode. */
+    conflictMessage: string;
+}
+
+/** A host notification `useSkillEditorSubmit` asks to be shown. */
+export declare interface SkillEditorSubmitNotification {
+    /** Notification style. */
+    variant: NotificationVariant;
+    /** Optional heading. */
+    title?: string;
+    /** Body text. */
+    message: string;
+    /** W3C trace ID, when the triggering error carried one. */
+    requestId?: string;
+}
+
+/** Localized messages `useSkillFileActions` needs beyond per-candidate batch validation. */
+export declare interface SkillFileActionsMessages extends SkillFileBatchValidationMessages {
+    /** Returned as the commit error when an imported manifest's `name` doesn't match the skill being edited. */
+    manifestNameMismatch: string;
+    /** Returned as the commit error when the user declines the manifest-import confirmation. */
+    manifestImportDeclined: string;
+    /** Generic fallback commit error for a batch with invalid candidates but no specific batch error. */
+    saveError: string;
+}
+
+/** Snapshot of editor state the batch validator projects new totals against. */
+export declare interface SkillFileBatchValidationContext {
+    /** Paths already present in the editor's supporting-file tree. */
+    existingPaths: string[];
+    /** Sum of the bytes already held for existing supporting files. */
+    existingTotalBytes: number;
+    /** UTF-8 byte length of the currently generated/loaded root `SKILL.md`. */
+    manifestByteLength: number;
+    /** Localized messages. */
+    messages: SkillFileBatchValidationMessages;
+}
+
+/** Localized messages the batch validator needs, resolved by the caller. */
+export declare interface SkillFileBatchValidationMessages {
+    /** Shown when a required field (e.g. a candidate's path) is empty. */
+    required: string;
+    /** Shown when a candidate's path collides with a reserved entry name. */
+    pathReserved: string;
+    /** Shown when a candidate's path fails DIAL's relative-path rules. */
+    pathInvalid: string;
+    /** Shown when a candidate's path duplicates another candidate or an existing file. */
+    pathDuplicate: string;
+    /** Shown when a candidate exceeds the per-file size limit; receives the formatted limit. */
+    fileTooLarge: (maxSize: string) => string;
+    /** Shown when a root-level `SKILL.md`-like path has the wrong casing. */
+    manifestCasingInvalid: string;
+    /** Shown when the batch stages more than one root `SKILL.md`. */
+    manifestDuplicate: string;
+    /** Shown when a root `SKILL.md`'s bytes are not valid UTF-8. */
+    manifestInvalidUtf8: string;
+    /** Shown when a root `SKILL.md`'s frontmatter is missing or missing `name`/`description`. */
+    manifestInvalidFrontmatter: string;
+    /** Shown when the batch's projected total package size exceeds the limit. */
+    totalSizeExceeded: string;
+    /** Shown when the batch's projected total file count exceeds the limit. */
+    totalCountExceeded: string;
+}
+
+/** Result of validating a whole staged batch. */
+export declare interface SkillFileBatchValidationOutcome {
+    /** One result per candidate, in the same order as the input. */
+    results: SkillFileValidationResult[];
+    /** Batch-level errors (projected total size/count, multiple manifests). */
+    batchErrors: SkillFileBatchError[];
+    /** The single accepted manifest import, when the batch has exactly one valid `SKILL.md`. */
+    manifestCandidate?: SkillManifestImportCandidate;
+}
+
+/** Wraps raw bytes in a `Blob`, copying them so the source buffer can be reused. */
+export declare const skillFileBytesToBlob: (bytes: Uint8Array) => Blob;
+
+/**
+ * In-memory bytes for a Skill supporting file, plus its MIME type when known
+ * (e.g. from a browser upload's `File.type`).
+ */
+export declare interface SkillFileContent {
+    /** The file's raw bytes. */
+    bytes: Uint8Array;
+    /**
+     * MIME type from the original browser `File.type`. Omit for edit-mode ZIP
+     * entries, which carry no MIME metadata — the type is then inferred from
+     * the file's path.
+     */
+    mimeType?: string;
+}
+
+/** The ordered supporting-file paths and `Blob` payload `createSkill`/`updateSkill` expect. */
+export declare interface SkillFilesPayload {
+    /** Relative paths, positionally paired with `files`. */
+    filePaths: string[];
+    /** File contents, positionally paired with `filePaths`. */
+    files: Blob[];
+}
+
+/**
+ * Converts a Skill supporting file's in-memory bytes into the `Attachment`
+ * shape the chat attachment-canvas pipeline expects, so it can be previewed
+ * with `useOpenAttachmentCanvas` exactly like a chat attachment. The id is
+ * the file's full relative path (not its basename), so two files with the
+ * same name in different folders never collide.
+ */
+export declare const skillFileToAttachment: (node: SkillFileTreeNode, content: SkillFileContent) => Attachment;
+
+/** A `SKILL.md` split into its frontmatter fields and its prose body. */
+export declare interface SkillManifestDocument {
+    /** `name` frontmatter field, when present and a string. */
+    name?: string;
+    /** `description` frontmatter field, when present and a string. */
+    description?: string;
+    /** Recognised `about.*` frontmatter fields. Absent when none resolved. */
+    about?: SkillAboutDetails;
+    /** Everything after the frontmatter fence, or the whole file when there is none. */
+    body: string;
+}
+
+/** A recognized, structurally valid manifest candidate from a staged batch. */
+export declare interface SkillManifestImportCandidate {
+    /** The `SkillFileUploadCandidate.id` this manifest came from. */
+    candidateId: string;
+    /** The imported manifest's `name` field. */
+    name: string;
+    /** The imported manifest's `description` field. */
+    description: string;
+    /** The imported manifest's full parsed frontmatter, including unknown fields. */
+    frontmatter: Record<string, unknown>;
+    /** The imported manifest's instructions body. */
+    instructions: string;
+}
+
+/** Skill fields serialized into the `SKILL.md` manifest. */
+export declare interface SkillManifestValues {
+    /** Normalized skill name. */
+    name: string;
+    /** Short description of what the skill does. */
+    description: string;
+    /** The skill's instructions body (Markdown). */
+    instructions: string;
+}
+
+declare type SubmitPhase = 'idle' | 'submitting' | 'success' | 'failure';
+
+/** A skill archive unpacked into its manifest text and a relative-path → bytes map of every other entry. */
+export declare interface UnpackedSkillArchive {
+    /** The root `SKILL.md` entry's decoded text content. */
+    manifestText: string;
+    /** Every non-manifest entry, keyed by relative path. */
+    files: Map<string, Uint8Array>;
+}
+
+/**
+ * Unpacks a whole-skill ZIP (as downloaded from `GET /api/v1/skills/download`
+ * — DIAL Core's whole-resource `GET` is the one place this contract still
+ * uses a ZIP, per design.md) into its manifest text and every other entry's
+ * bytes. Throws if the archive has no root `SKILL.md` entry.
+ */
+export declare const unpackSkillArchive: (bytes: Uint8Array) => UnpackedSkillArchive;
+
+/**
+ * Owns the edit-mode skill download/unpack/parse flow: the in-memory
+ * supporting-file map, the loaded manifest values and frontmatter, the
+ * concurrency ETag, and the load-state machine driving the form's
+ * loading/error/forbidden/not-found presentation. Create mode never leaves
+ * `'loaded'` and starts with empty state.
+ */
+export declare const useSkillEditorLoad: ({ isEditMode, bucket, skillPath, client, }: UseSkillEditorLoadParams) => UseSkillEditorLoadResult;
+
+/** Parameters accepted by {@link useSkillEditorLoad}. */
+export declare interface UseSkillEditorLoadParams {
+    /** Whether the form is editing an existing skill rather than creating a new one. */
+    isEditMode: boolean;
+    /** DIAL Core bucket holding the skill. Load is skipped until this resolves. */
+    bucket: string | undefined;
+    /** Path to the skill within `bucket`. */
+    skillPath: string | null | undefined;
+    /** Already-configured download operations. */
+    client: SkillEditorLoadClient;
+}
+
+/** Return value of {@link useSkillEditorLoad}. */
+export declare interface UseSkillEditorLoadResult {
+    /** Current load-state machine value driving the form's presentation. */
+    loadState: SkillEditorLoadState;
+    /** The loaded (or, in create mode, seeded) manifest values. */
+    loadedValues: SkillEditorValues | undefined;
+    /** Updates `loadedValues`, e.g. after a manifest import. */
+    setLoadedValues: Dispatch<SetStateAction<SkillEditorValues | undefined>>;
+    /** The loaded supporting-file tree. */
+    files: SkillFileTreeNode[];
+    /** Updates `files`, e.g. after a batch commit or node removal. */
+    setFiles: Dispatch<SetStateAction<SkillFileTreeNode[]>>;
+    /** In-memory bytes for every supporting file, keyed by relative path. */
+    filesContentRef: React.MutableRefObject<Map<string, SkillFileContent>>;
+    /** The loaded manifest's full parsed frontmatter, including fields the form never renders. */
+    frontmatterRef: React.MutableRefObject<Record<string, unknown>>;
+    /** The concurrency ETag from the load, sent back as `If-Match` on save. */
+    etagRef: React.MutableRefObject<string | undefined>;
+    /** The skill path the currently loaded state belongs to. */
+    loadedPathRef: React.MutableRefObject<string | undefined>;
+    /** Re-attempts the edit-mode download (load-error retry or post-conflict reload). */
+    retryLoad: () => void;
+}
+
+/**
+ * Owns the Skill Editor's create/edit submission flow: field validation,
+ * building and (in edit mode) merging the `SKILL.md` manifest, calling
+ * `client.createSkill`/`client.updateSkill`, and mapping the resulting
+ * success/error/conflict outcomes to presentable state.
+ */
+export declare const useSkillEditorSubmit: ({ bucket, isEditMode, files, filesContentRef, frontmatterRef, loadedPathRef, etagRef, returnUrl, refetchSkills, client, messages, onNavigate, onNotify, }: UseSkillEditorSubmitParams) => UseSkillEditorSubmitResult;
+
+/** Parameters accepted by {@link useSkillEditorSubmit}. */
+export declare interface UseSkillEditorSubmitParams {
+    /** DIAL Core bucket the skill is saved to. */
+    bucket: string | undefined;
+    /** Whether the form is editing an existing skill rather than creating a new one. */
+    isEditMode: boolean;
+    /** The editor's current supporting-file tree. */
+    files: SkillFileTreeNode[];
+    /** In-memory bytes for every supporting file, keyed by relative path. */
+    filesContentRef: React.MutableRefObject<Map<string, SkillFileContent>>;
+    /** The loaded (or imported) manifest's full parsed frontmatter. */
+    frontmatterRef: React.MutableRefObject<Record<string, unknown>>;
+    /** The path the currently loaded edit-mode state belongs to. */
+    loadedPathRef: React.MutableRefObject<string | undefined>;
+    /** The concurrency ETag from the load, sent back as `If-Match` on save. */
+    etagRef: React.MutableRefObject<string | undefined>;
+    /** Where to navigate on a successful save. */
+    returnUrl: string;
+    /** Refetches the host's skill listing after a successful save. */
+    refetchSkills: () => Promise<void>;
+    /** Already-configured create/update operations. */
+    client: SkillEditorSubmitClient;
+    /** Localized messages, resolved by the host. */
+    messages: SkillEditorSubmitMessages;
+    /** Called with `returnUrl` after a successful save. */
+    onNavigate: (url: string) => void;
+    /** Called to surface a host notification (success toast or unexpected-error toast). */
+    onNotify: (notification: SkillEditorSubmitNotification) => void;
+}
+
+/** Return value of {@link useSkillEditorSubmit}. */
+export declare interface UseSkillEditorSubmitResult {
+    /** Current submit-phase. */
+    phase: SubmitPhase;
+    /** Inline field validation errors. */
+    errors: SkillEditorErrors;
+    /** General submit-time error, distinct from a stale-edit `conflict`. */
+    submitError: string | undefined;
+    /** Present when the last save hit a stale-ETag conflict. */
+    conflict: {
+        message: string;
+    } | undefined;
+    /** Clears `conflict`, e.g. once the host has reloaded the latest skill. */
+    clearConflict: () => void;
+    /** Validates and submits the given form values. */
+    handleSubmit: (values: SkillEditorValues) => Promise<void>;
+}
+
+/**
+ * Owns the Skill Editor's batch file upload workflow: validating a staged
+ * batch, committing it atomically (supporting files plus an optional
+ * `SKILL.md` manifest import, with a confirmation gate), and removing
+ * already-committed nodes.
+ */
+export declare const useSkillFileActions: ({ files, setFiles, filesContentRef, frontmatterRef, loadedValues, setLoadedValues, isEditMode, isDirty, setSelectedPath, messages, }: UseSkillFileActionsParams) => UseSkillFileActionsResult;
+
+/** Parameters accepted by {@link useSkillFileActions}. */
+export declare interface UseSkillFileActionsParams {
+    /** The editor's current supporting-file tree. */
+    files: SkillFileTreeNode[];
+    /** Updates `files`. */
+    setFiles: Dispatch<SetStateAction<SkillFileTreeNode[]>>;
+    /** In-memory bytes for every supporting file, keyed by relative path. */
+    filesContentRef: React.MutableRefObject<Map<string, SkillFileContent>>;
+    /** The loaded (or imported) manifest's full parsed frontmatter. */
+    frontmatterRef: React.MutableRefObject<Record<string, unknown>>;
+    /** The seeded baseline manifest values, used to approximate the projected total size. */
+    loadedValues: SkillEditorValues | undefined;
+    /** Updates `loadedValues` after a manifest import. */
+    setLoadedValues: Dispatch<SetStateAction<SkillEditorValues | undefined>>;
+    /** Whether the form is editing an existing skill rather than creating a new one. */
+    isEditMode: boolean;
+    /** Whether the form currently diverges from its seeded baseline. */
+    isDirty: boolean;
+    /** Updates the currently selected file-tree node path. */
+    setSelectedPath: Dispatch<SetStateAction<string>>;
+    /** Localized messages, resolved by the host. */
+    messages: SkillFileActionsMessages;
+}
+
+/** Return value of {@link useSkillFileActions}. */
+export declare interface UseSkillFileActionsResult {
+    /** File-tree mutation operations, passed straight to `SkillEditor`'s `fileActions` prop. */
+    fileActions: SkillEditorFileActions;
+    /** Whether the "replace Skill metadata?" confirmation prompt should be shown. */
+    pendingManifestImport: boolean;
+    /** Resolves the in-flight manifest-import confirmation with the user's choice. */
+    resolveManifestImport: (accepted: boolean) => void;
+}
+
+/**
+ * Validates a whole staged upload batch against per-file limits, path
+ * safety, in-batch/against-existing duplicates, and projected total
+ * size/count — mirroring the BFF's authoritative `SkillsPackageService`
+ * limits for immediate feedback (the server remains the final gate). Reads
+ * each candidate's bytes only where required (the root `SKILL.md` manifest,
+ * to decode and parse its frontmatter) — never for an ordinary supporting
+ * file, whose size is checked via `File.size` alone.
+ */
+export declare const validateSkillFileBatch: (candidates: SkillFileUploadCandidate[], context: SkillFileBatchValidationContext) => Promise<SkillFileBatchValidationOutcome>;
+
+export { }

package/skill-editor.js

@@ -0,0 +1,3 @@
+import { a as e, c as t, d as n, f as r, h as i, i as a, l as o, m as s, n as c, o as l, p as u, r as d, s as f, t as p, u as m } from "./skill-manifest-CCX8s4nn.js";
+import { a as h, i as g, n as _, o as v, r as y, t as b } from "./useSkillFileActions-BU5PzZ_8.js";
+export { c as SKILL_FILE_UPLOAD_MAX_BYTES, d as SKILL_MANIFEST_FILE, a as SKILL_UPLOAD_MAX_FILES, e as SKILL_UPLOAD_MAX_TOTAL_BYTES, y as SkillEditorLoadState, l as buildSkillFilesPayload, f as buildSkillManifest, t as buildSkillManifestForSubmit, o as buildSkillManifestFromFrontmatter, m as isValidSkillRelativePath, n as nameFromPath, r as normalizeSkillName, u as parseSkillManifest, p as parseSkillManifestDocument, s as skillFileBytesToBlob, h as skillFileToAttachment, i as unpackSkillArchive, g as useSkillEditorLoad, _ as useSkillEditorSubmit, b as useSkillFileActions, v as validateSkillFileBatch };