@ggui-ai/artifact-manifest 0.1.0-rc.1

package/dist/blueprint-manifest.d.ts

@@ -0,0 +1,126 @@
+/**
+ * `ggui.blueprint.json` — author-side manifest for cached UI
+ * blueprints published to the ggui marketplace.
+ *
+ * Blueprints are the OTHER artifact kind the registry hosts (beside
+ * gadgets). A blueprint bundles:
+ *
+ *   - **TSX source** — the React component body the runtime renders.
+ *   - **DataContract** (optional) — the contract shape this blueprint
+ *     was designed for. Consumed by the cache-match path.
+ *   - **fixtureProps** (optional) — sample props used by the
+ *     conformance gate's runtime probe.
+ *   - **variance tags** (optional) — persona / aesthetic / context
+ *     hints that drive the LLM-driven variant selector when multiple
+ *     blueprints share a `(appId, contractHash)` group.
+ *
+ * ## In-process counterpart
+ *
+ * The in-process registration tool at
+ * `cloud/ggui-protocol-pod/src/tools/register-blueprint.ts` accepts
+ * `{source, contract?, fixtureProps?}` and a slug
+ * `^[a-z0-9][a-z0-9_-]{0,63}$`. This manifest's `source` /
+ * `contract` / `fixtureProps` fields mirror that envelope exactly
+ * — round-tripping a blueprint through
+ * `ggui_ops_register_blueprint` then exporting it back into a
+ * `ggui.blueprint.json` must not require any field rewriting beyond
+ * adding the marketplace identity (`scope`, `name`, `version`,
+ * `kind`, `visibility`) and optional variance tags.
+ *
+ * The `name` regex matches the in-process slug rule
+ * ({@link BLUEPRINT_NAME_RE}) — diverging would break round-trip.
+ *
+ * ## Why no `matchers` field
+ *
+ * The existing `screen-blueprints/match.ts` matcher operates on the
+ * runtime-side `MatchableBlueprint` row (carries `blueprintId`,
+ * `serverId`, `dataTools`, `status`) — these are runtime registry
+ * artifacts, not authoring-time manifest declarations. The selector
+ * for cached-blueprint variants reads {@link BlueprintVariance}
+ * (persona + aesthetic + context + seedPrompt), which IS authoring-
+ * time information and lives on this manifest under `variance`.
+ *
+ * If a future authoring-time matchers shape lands in
+ * `@ggui-ai/protocol`, add it here under `matchers?:
+ * BlueprintMatchers` and reuse the protocol type. Don't redefine it.
+ *
+ * ## Discriminator
+ *
+ * The top-level `kind: "blueprint"` literal is the discriminator
+ * {@link artifactManifestSchema} uses to narrow between gadget and
+ * blueprint manifests. Authors MUST set it.
+ *
+ * ## Strictness
+ *
+ * Root + nested objects are strict — unknown keys fail parse. Same
+ * loud-feedback posture as the gadget manifest.
+ */
+import { z } from 'zod';
+import { type BlueprintVariance, type DataContract } from '@ggui-ai/protocol';
+/**
+ * Strict zod schema for `ggui.blueprint.json`. Strict root — unknown
+ * keys fail parse. Discriminated on `kind: "blueprint"`.
+ *
+ * Note: `contract` is intentionally NOT made strict here — it
+ * delegates to {@link dataContractSchema} from `@ggui-ai/protocol`,
+ * which owns its own strictness posture (and `JsonSchema` body fields
+ * are deliberately open).
+ */
+export declare const blueprintManifestSchema: z.ZodObject<{
+    description: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    author: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        email: z.ZodOptional<z.ZodEmail>;
+        url: z.ZodOptional<z.ZodURL>;
+    }, z.core.$strict>>;
+    license: z.ZodOptional<z.ZodString>;
+    homepage: z.ZodOptional<z.ZodURL>;
+    kind: z.ZodLiteral<"blueprint">;
+    scope: z.ZodString;
+    name: z.ZodString;
+    version: z.ZodString;
+    source: z.ZodString;
+    visibility: z.ZodEnum<{
+        public: "public";
+        private: "private";
+    }>;
+    contract: z.ZodOptional<z.ZodType<DataContract, unknown, z.core.$ZodTypeInternals<DataContract, unknown>>>;
+    fixtureProps: z.ZodOptional<z.ZodUnknown>;
+    variance: z.ZodOptional<z.ZodType<BlueprintVariance, unknown, z.core.$ZodTypeInternals<BlueprintVariance, unknown>>>;
+}, z.core.$strict>;
+/**
+ * Static TypeScript type derived from {@link blueprintManifestSchema}.
+ *
+ * Authors writing `ggui.blueprint.json` should
+ * `import type { BlueprintManifest } from '@ggui-ai/artifact-manifest'`
+ * and let inference flow. The `contract` field is typed `DataContract
+ * | undefined` (reuses the protocol type); `variance` is typed
+ * `BlueprintVariance | undefined` (also reused).
+ */
+export type BlueprintManifest = z.infer<typeof blueprintManifestSchema>;
+/**
+ * Canonical filename — always at the blueprint repo root, always
+ * this name. Exported so tooling uses the constant instead of
+ * hard-coding the string.
+ */
+export declare const GGUI_BLUEPRINT_JSON_FILENAME = "ggui.blueprint.json";
+/**
+ * Parse a raw JSON value into a validated {@link BlueprintManifest}.
+ * Throws a `ZodError` with human-readable issues on invalid input.
+ *
+ * Accepts any `unknown` — callers are expected to have already
+ * decoded the JSON (`JSON.parse(source)`).
+ */
+export declare function parseBlueprintManifest(raw: unknown): BlueprintManifest;
+/**
+ * Assertion helper — narrows `raw` to {@link BlueprintManifest} on
+ * success, throws `ZodError` on failure.
+ */
+export declare function assertBlueprintManifestValid(raw: unknown): asserts raw is BlueprintManifest;
+/**
+ * Safe-parse variant — returns a discriminated `z.safeParse` result
+ * (`{ success: true, data }` vs `{ success: false, error }`).
+ */
+export declare function safeParseBlueprintManifest(raw: unknown): ReturnType<typeof blueprintManifestSchema.safeParse>;
+//# sourceMappingURL=blueprint-manifest.d.ts.map

package/dist/blueprint-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blueprint-manifest.d.ts","sourceRoot":"","sources":["../src/blueprint-manifest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,YAAY,EAGlB,MAAM,mBAAmB,CAAC;AAgC3B;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;kBAiDlC,CAAC;AAEH;;;;;;;;GAQG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAmBxE;;;;GAIG;AACH,eAAO,MAAM,4BAA4B,wBAAwB,CAAC;AAElE;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,OAAO,GAAG,iBAAiB,CAEtE;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,CAC1C,GAAG,EAAE,OAAO,GACX,OAAO,CAAC,GAAG,IAAI,iBAAiB,CAElC;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,OAAO,GACX,UAAU,CAAC,OAAO,uBAAuB,CAAC,SAAS,CAAC,CAEtD"}

package/dist/blueprint-manifest.js

@@ -0,0 +1,159 @@
+/**
+ * `ggui.blueprint.json` — author-side manifest for cached UI
+ * blueprints published to the ggui marketplace.
+ *
+ * Blueprints are the OTHER artifact kind the registry hosts (beside
+ * gadgets). A blueprint bundles:
+ *
+ *   - **TSX source** — the React component body the runtime renders.
+ *   - **DataContract** (optional) — the contract shape this blueprint
+ *     was designed for. Consumed by the cache-match path.
+ *   - **fixtureProps** (optional) — sample props used by the
+ *     conformance gate's runtime probe.
+ *   - **variance tags** (optional) — persona / aesthetic / context
+ *     hints that drive the LLM-driven variant selector when multiple
+ *     blueprints share a `(appId, contractHash)` group.
+ *
+ * ## In-process counterpart
+ *
+ * The in-process registration tool at
+ * `cloud/ggui-protocol-pod/src/tools/register-blueprint.ts` accepts
+ * `{source, contract?, fixtureProps?}` and a slug
+ * `^[a-z0-9][a-z0-9_-]{0,63}$`. This manifest's `source` /
+ * `contract` / `fixtureProps` fields mirror that envelope exactly
+ * — round-tripping a blueprint through
+ * `ggui_ops_register_blueprint` then exporting it back into a
+ * `ggui.blueprint.json` must not require any field rewriting beyond
+ * adding the marketplace identity (`scope`, `name`, `version`,
+ * `kind`, `visibility`) and optional variance tags.
+ *
+ * The `name` regex matches the in-process slug rule
+ * ({@link BLUEPRINT_NAME_RE}) — diverging would break round-trip.
+ *
+ * ## Why no `matchers` field
+ *
+ * The existing `screen-blueprints/match.ts` matcher operates on the
+ * runtime-side `MatchableBlueprint` row (carries `blueprintId`,
+ * `serverId`, `dataTools`, `status`) — these are runtime registry
+ * artifacts, not authoring-time manifest declarations. The selector
+ * for cached-blueprint variants reads {@link BlueprintVariance}
+ * (persona + aesthetic + context + seedPrompt), which IS authoring-
+ * time information and lives on this manifest under `variance`.
+ *
+ * If a future authoring-time matchers shape lands in
+ * `@ggui-ai/protocol`, add it here under `matchers?:
+ * BlueprintMatchers` and reuse the protocol type. Don't redefine it.
+ *
+ * ## Discriminator
+ *
+ * The top-level `kind: "blueprint"` literal is the discriminator
+ * {@link artifactManifestSchema} uses to narrow between gadget and
+ * blueprint manifests. Authors MUST set it.
+ *
+ * ## Strictness
+ *
+ * Root + nested objects are strict — unknown keys fail parse. Same
+ * loud-feedback posture as the gadget manifest.
+ */
+import { z } from 'zod';
+import { blueprintVarianceSchema, dataContractSchema, } from '@ggui-ai/protocol';
+import { ArtifactScopeSchema, ArtifactVersionSchema, ArtifactVisibilitySchema, BLUEPRINT_NAME_RE, sharedMetadataShape, } from './base.js';
+/**
+ * Blueprint name regex — the same kebab-case rule as gadgets. See
+ * {@link BLUEPRINT_NAME_RE} for the rationale.
+ */
+const BlueprintNameSchema = z.string().min(2).max(64).regex(BLUEPRINT_NAME_RE, {
+    message: 'name must be 2-64 chars matching `^[a-z0-9][a-z0-9-]{0,62}[a-z0-9]$` (lowercase alphanumerics + hyphens, no underscores, no single-character names).',
+});
+/**
+ * `fixtureProps` is intentionally `unknown` — the conformance gate's
+ * runtime probe round-trips it through `JSON.stringify` and feeds it
+ * as `props` to the rendered TSX. Any JSON-safe shape rides through;
+ * the blueprint's own `contract.propsSchema` (when present) is what
+ * actually validates the shape at runtime probe time. Mirrors the
+ * in-process register-blueprint's `fixtureProps: z.unknown().optional()`.
+ *
+ * `z.unknown()` is permitted here (not `Record<string, unknown>`)
+ * because the value is genuinely shape-unknown at THIS layer — only
+ * the blueprint's own contract knows what shape its props take.
+ */
+const fixturePropsSchema = z.unknown();
+/**
+ * Strict zod schema for `ggui.blueprint.json`. Strict root — unknown
+ * keys fail parse. Discriminated on `kind: "blueprint"`.
+ *
+ * Note: `contract` is intentionally NOT made strict here — it
+ * delegates to {@link dataContractSchema} from `@ggui-ai/protocol`,
+ * which owns its own strictness posture (and `JsonSchema` body fields
+ * are deliberately open).
+ */
+export const blueprintManifestSchema = z.strictObject({
+    // ---- Discriminator ----
+    kind: z
+        .literal('blueprint')
+        .describe('Discriminator — picks the blueprint variant of the artifact-manifest union. MUST be the literal string `"blueprint"`.'),
+    // ---- Identity (required) ----
+    scope: ArtifactScopeSchema.describe('Blueprint scope. Must start with `@` (e.g. `@my-org`). Disambiguates the `<scope>/<name>` install identifier.'),
+    name: BlueprintNameSchema.describe('Blueprint slug. 2-64 chars, `^[a-z0-9][a-z0-9-]{0,62}[a-z0-9]$` — kebab-case, no underscores, no single-character names. Unified with the gadget naming rule under LOCKED-25 (2026-05-18). The in-process `ggui_ops_register_blueprint` slug rule mirrors this for round-trip preservation.'),
+    version: ArtifactVersionSchema.describe('SemVer. `MAJOR.MINOR.PATCH` with optional `-pre` / `+build` suffixes. Per-version immutable once published.'),
+    // ---- Core blueprint shape (required: source) ----
+    source: z
+        .string()
+        .min(1)
+        .describe('TSX source body with a default-exported React component. Mirrors the in-process register-blueprint `blueprint.source` field — the conformance gate compiles + runtime-probes this string before the registry accepts the upload.'),
+    visibility: ArtifactVisibilitySchema.describe('Storage + signing posture. `public` = sigstore-signed, listable; `private` = Ed25519-signed, visible only within publisher org.'),
+    // ---- Optional core blueprint shape ----
+    contract: dataContractSchema
+        .optional()
+        .describe("The DataContract envelope this blueprint was designed for. Consumed by the cache-match path to short-circuit cold gen when an agent's contract hash matches. Optional — a blueprint can publish without a contract for cases where the matcher relies on variance + tags only."),
+    fixtureProps: fixturePropsSchema
+        .optional()
+        .describe("Sample props for the conformance gate's runtime probe. Any JSON-safe shape; validated for top-level required-key shape against `contract.propsSpec.properties` at static gate time and used as the input props on the sandboxed React render in the runtime probe."),
+    variance: blueprintVarianceSchema
+        .optional()
+        .describe("Persona + aesthetic + context + seedPrompt hints that drive the LLM-driven variant selector when multiple blueprints share a `(appId, contractHash)` group. Mirrors `Blueprint.variance` in `@ggui-ai/protocol`."),
+    // ---- Shared metadata ----
+    ...sharedMetadataShape,
+});
+// Verify the manifest TS type actually projects the reused protocol
+// types — if a future zod-vs-TS drift slips one of these to `any`,
+// the parameter-to-return-type assignments below stop compiling.
+// Module-private static checks; the bodies are never invoked.
+function _blueprintContractTypeCheck(c) {
+    return c;
+}
+function _blueprintVarianceTypeCheck(v) {
+    return v;
+}
+void _blueprintContractTypeCheck;
+void _blueprintVarianceTypeCheck;
+/**
+ * Canonical filename — always at the blueprint repo root, always
+ * this name. Exported so tooling uses the constant instead of
+ * hard-coding the string.
+ */
+export const GGUI_BLUEPRINT_JSON_FILENAME = 'ggui.blueprint.json';
+/**
+ * Parse a raw JSON value into a validated {@link BlueprintManifest}.
+ * Throws a `ZodError` with human-readable issues on invalid input.
+ *
+ * Accepts any `unknown` — callers are expected to have already
+ * decoded the JSON (`JSON.parse(source)`).
+ */
+export function parseBlueprintManifest(raw) {
+    return blueprintManifestSchema.parse(raw);
+}
+/**
+ * Assertion helper — narrows `raw` to {@link BlueprintManifest} on
+ * success, throws `ZodError` on failure.
+ */
+export function assertBlueprintManifestValid(raw) {
+    blueprintManifestSchema.parse(raw);
+}
+/**
+ * Safe-parse variant — returns a discriminated `z.safeParse` result
+ * (`{ success: true, data }` vs `{ success: false, error }`).
+ */
+export function safeParseBlueprintManifest(raw) {
+    return blueprintManifestSchema.safeParse(raw);
+}

package/dist/gadget-manifest.d.ts

@@ -0,0 +1,180 @@
+/**
+ * `ggui.gadget.json` — author-side manifest for ggui gadgets
+ * published to the marketplace.
+ *
+ * Lives at the root of a gadget author's repo (one repo = one gadget).
+ * `ggui publish` reads this file, builds the bundle, runs the local
+ * conformance gate, then uploads bundle + sig + descriptor to the
+ * resolved registry. End-users install via `ggui install
+ * <scope/name@version>` which appends to their app's
+ * `ggui.json#app.gadgets`.
+ *
+ * ## Relationship to `strictGadgetDescriptorSchema`
+ *
+ * The registry-side `strictGadgetDescriptorSchema` (in
+ * `@ggui-ai/protocol`) describes what a wrapper looks like *after* it
+ * has been registered (it carries `package` / `bundleUrl` / etc — the
+ * fetchable shape). This author-side manifest describes what a wrapper
+ * looks like *before* publish (build-config + identity + signing
+ * posture). Field semantics agree where they overlap:
+ *
+ *   | Field         | author manifest        | registry entry           |
+ *   |---------------|------------------------|--------------------------|
+ *   | `scope`       | required (`@org`)      | implicit in entry key    |
+ *   | `name`        | required (kebab-case)  | implicit in entry key    |
+ *   | `version`     | required (semver)      | required                 |
+ *   | `exports[]`   | required (≥1)          | required (`exports[]`)   |
+ *   | `description` | required (pkg summary) | REQUIRED at registry     |
+ *   | `requires[]`  | `GGUI_PUBLIC_APP_*`    | same regex (locked)      |
+ *   | `connect[]`   | URL allowlist          | same shape (`string[]`)  |
+ *   | `bundle`      | source entry path      | replaced by `bundleUrl`  |
+ *   | `style`       | source entry path      | replaced by `styleUrl`   |
+ *   | `visibility`  | required (pub/priv)    | not on registry entry    |
+ *   | `peerDeps`    | conformance allowlist  | not on registry entry    |
+ *
+ * The schemas are deliberately separate — manifest carries build
+ * config, registry entry carries fetch URLs. The publish flow
+ * translates one into the other. Don't import `registryGadget
+ * EntrySchema` and extend it; the shapes overlap but are not subset/
+ * superset.
+ *
+ * ## Discriminator
+ *
+ * The top-level `kind: "gadget"` literal is the discriminator that
+ * lets {@link artifactManifestSchema} narrow between gadget and
+ * blueprint manifests. Authors MUST set it; the schema rejects
+ * absent or misspelled `kind` with a clear path-`["kind"]` issue.
+ *
+ * ## Strictness
+ *
+ * Root + nested objects are strict — unknown keys fail parse. This is
+ * the gadget author's first feedback surface; typos in
+ * `ggui.gadget.json` should fail loud, not silently get ignored at
+ * publish time.
+ */
+import { z } from 'zod';
+/**
+ * One export of a gadget package — a hook or a component. Mirrors the
+ * protocol's `GadgetExport` shape: a gadget package bundles ≥1 of
+ * these behind a single npm identity. There is no `kind` field —
+ * discrimination is by field presence: a `hook` key (`use`-prefixed
+ * name) marks a hook, a `component` key (PascalCase name) marks a
+ * component.
+ */
+export declare const gadgetExportSchema: z.ZodUnion<readonly [z.ZodObject<{
+    description: z.ZodString;
+    usage: z.ZodString;
+    example: z.ZodType<import("@ggui-ai/protocol").JsonValue, unknown, z.core.$ZodTypeInternals<import("@ggui-ai/protocol").JsonValue, unknown>>;
+    gotchas: z.ZodOptional<z.ZodString>;
+    hook: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    description: z.ZodString;
+    usage: z.ZodString;
+    example: z.ZodType<import("@ggui-ai/protocol").JsonValue, unknown, z.core.$ZodTypeInternals<import("@ggui-ai/protocol").JsonValue, unknown>>;
+    gotchas: z.ZodOptional<z.ZodString>;
+    component: z.ZodString;
+}, z.core.$strict>]>;
+/**
+ * Strict zod schema for `ggui.gadget.json`. Strict root + nested
+ * objects — unknown keys fail parse. Discriminated on `kind:
+ * "gadget"`.
+ */
+export declare const gadgetManifestSchema: z.ZodObject<{
+    connect: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    tags: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    author: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        email: z.ZodOptional<z.ZodEmail>;
+        url: z.ZodOptional<z.ZodURL>;
+    }, z.core.$strict>>;
+    license: z.ZodOptional<z.ZodString>;
+    homepage: z.ZodOptional<z.ZodURL>;
+    kind: z.ZodLiteral<"gadget">;
+    scope: z.ZodString;
+    name: z.ZodString;
+    version: z.ZodString;
+    exports: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        description: z.ZodString;
+        usage: z.ZodString;
+        example: z.ZodType<import("@ggui-ai/protocol").JsonValue, unknown, z.core.$ZodTypeInternals<import("@ggui-ai/protocol").JsonValue, unknown>>;
+        gotchas: z.ZodOptional<z.ZodString>;
+        hook: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        description: z.ZodString;
+        usage: z.ZodString;
+        example: z.ZodType<import("@ggui-ai/protocol").JsonValue, unknown, z.core.$ZodTypeInternals<import("@ggui-ai/protocol").JsonValue, unknown>>;
+        gotchas: z.ZodOptional<z.ZodString>;
+        component: z.ZodString;
+    }, z.core.$strict>]>>;
+    bundle: z.ZodString;
+    visibility: z.ZodEnum<{
+        public: "public";
+        private: "private";
+    }>;
+    description: z.ZodString;
+    style: z.ZodOptional<z.ZodString>;
+    /**
+     * `requires` — App-side public-env keys the wrapper needs to
+     * function. Each entry MUST match `GGUI_PUBLIC_APP_*`. The shared
+     * `gadgetRequiresSchema` from `@ggui-ai/protocol` is the single
+     * source of truth for this constraint.
+     */
+    requires: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    peerDeps: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    /**
+     * Author-default registry hostname the wrapper publishes to. Forms
+     * the third tier of bundleHost resolution at push time:
+     *
+     *   1. operator's `app.gadgets[*].bundleUrl` (full URL, escape hatch)
+     *   2. operator's `app.gadgets[*].bundleHost` (override)
+     *   3. THIS field — gadget author's default
+     *   4. spec default `registry.ggui.ai`
+     *
+     * Most wrappers omit this (they publish to the hosted registry, and
+     * the spec default covers them). Set this only when the wrapper ships
+     * via a non-default registry (private org registry, sandbox-only
+     * fixture, …). The operator override remains the right knob for
+     * sandbox-vs-prod swaps.
+     *
+     * Hostname-only — no scheme, no path. Validated via
+     * {@link BUNDLE_HOST_RE} in `@ggui-ai/protocol`.
+     */
+    bundleHost: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * Static TypeScript type derived from {@link gadgetManifestSchema}.
+ *
+ * Authors writing `ggui.gadget.json` should `import type {
+ * GadgetManifest } from '@ggui-ai/artifact-manifest'` and let the
+ * inference flow.
+ */
+export type GadgetManifest = z.infer<typeof gadgetManifestSchema>;
+/**
+ * Canonical filename — always at the gadget repo root, always this
+ * name. Exported so tooling uses the constant instead of hard-coding
+ * the string.
+ */
+export declare const GGUI_GADGET_JSON_FILENAME = "ggui.gadget.json";
+/**
+ * Parse a raw JSON value into a validated {@link GadgetManifest}.
+ * Throws a `ZodError` with human-readable issues on invalid input.
+ *
+ * Accepts any `unknown` — callers are expected to have already
+ * decoded the JSON (`JSON.parse(source)`).
+ */
+export declare function parseGadgetManifest(raw: unknown): GadgetManifest;
+/**
+ * Assertion helper — narrows `raw` to {@link GadgetManifest} on
+ * success, throws `ZodError` on failure. Useful when the caller wants
+ * to keep the original reference (rather than the parsed copy
+ * `parseGadgetManifest` returns).
+ */
+export declare function assertGadgetManifestValid(raw: unknown): asserts raw is GadgetManifest;
+/**
+ * Safe-parse variant — returns a discriminated `z.safeParse` result
+ * (`{ success: true, data }` vs `{ success: false, error }`). Prefer
+ * this inside CLI tooling where you want to render the issue list
+ * without try/catch.
+ */
+export declare function safeParseGadgetManifest(raw: unknown): ReturnType<typeof gadgetManifestSchema.safeParse>;
+//# sourceMappingURL=gadget-manifest.d.ts.map

package/dist/gadget-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gadget-manifest.d.ts","sourceRoot":"","sources":["../src/gadget-manifest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAsFxB;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;oBAwB7B,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA4D/B;;;;;OAKG;;;IAcH;;;;;;;;;;;;;;;;;OAiBG;;kBAwBH,CAAC;AAEH;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,qBAAqB,CAAC;AAE5D;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,GAAG,cAAc,CAEhE;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,OAAO,GACX,OAAO,CAAC,GAAG,IAAI,cAAc,CAE/B;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,OAAO,GACX,UAAU,CAAC,OAAO,oBAAoB,CAAC,SAAS,CAAC,CAEnD"}