@honua/app-platform 0.0.20-alpha.0

package/studio/validate.js

@@ -0,0 +1,255 @@
+/**
+ * Family-agnostic validation for Studio packages produced outside Console —
+ * by an MCP client, the QGIS plugin, or the SDK itself. It returns the same
+ * unified {@link StudioPackageValidationResponse} envelope as the per-family
+ * validators, so a package generated through any surface is validated against
+ * one contract.
+ *
+ * For the `map` family this delegates to the established
+ * {@link validateMapPackage} (no duplication). For every other family it runs
+ * the shared base checks (`packageId`/`format`, lifecycle) and, when present,
+ * the shared {@link HonuaPackageProvenance} checks. Provenance is optional, but
+ * when a package carries it, MCP- and QGIS-origin packages must satisfy the
+ * same provenance shape as Console.
+ *
+ * @experimental Not yet covered by the SDK's semver contract — these shapes
+ *   may change in any minor release prior to `1.0.0`.
+ * @module
+ */
+import { validateMapPackage } from "../runtime/map-package-validation.js";
+import { HONUA_MAP_PACKAGE_FORMAT_V1 } from "../runtime/map-package.js";
+import { HONUA_PACKAGE_PROVENANCE_FORMAT_V1, getPackageProvenance } from "./provenance.js";
+import { STUDIO_PACKAGE_FAMILIES, isStudioPackageFamily } from "./types.js";
+import { fromMapPackageValidation } from "./validation.js";
+/**
+ * Expected `format` string for each family whose projection carries a single
+ * `format` discriminant. `map` and `dashboard` reuse their established
+ * constants; the `app` family is identified by `version` rather than `format`
+ * and is therefore not in this table.
+ */
+const FAMILY_FORMAT = {
+    query: "honua_query_package.v1",
+    analysis: "honua_analysis_package.v1",
+    map: HONUA_MAP_PACKAGE_FORMAT_V1,
+    dashboard: "honua_generated_app_manifest.v1",
+    report: "honua_report_package.v1",
+    form: "honua_form_package.v1",
+    workflow: "honua_workflow_package.v1",
+    gp: "honua_gp_package.v1",
+    etl: "honua_etl_package.v1",
+};
+/** The package-identity field each family uses. */
+function packageIdOf(family, value) {
+    if (family === "map")
+        return typeof value.mapPackageId === "string" ? value.mapPackageId : undefined;
+    if (family === "dashboard")
+        return typeof value.appId === "string" ? value.appId : undefined;
+    if (family === "app")
+        return typeof value.id === "string" ? value.id : undefined;
+    return typeof value.packageId === "string" ? value.packageId : undefined;
+}
+/**
+ * Validate a package of any Studio family produced outside Console. Dispatches
+ * to the map validator for the `map` family and applies shared base +
+ * provenance checks for every family.
+ *
+ * @experimental
+ */
+export function validateStudioPackage(family, value, options = {}) {
+    const diagnostics = [];
+    if (!isStudioPackageFamily(family)) {
+        diagnostics.push({
+            code: "unknown-family",
+            severity: "error",
+            message: `Unknown Studio package family "${family}". Expected one of: ${STUDIO_PACKAGE_FAMILIES.join(", ")}.`,
+            path: "packageFamily",
+        });
+        return { valid: false, diagnostics };
+    }
+    if (!isRecord(value)) {
+        diagnostics.push({
+            code: "invalid-package",
+            severity: "error",
+            message: `${family} package must be a JSON object.`,
+        });
+        return { valid: false, diagnostics };
+    }
+    // The map family has a full structural validator already — reuse it so MCP
+    // and QGIS map packages validate identically to Console's.
+    if (family === "map") {
+        const mapResponse = fromMapPackageValidation(validateMapPackage(value, { now: options.now }));
+        const merged = [...mapResponse.diagnostics];
+        appendProvenanceDiagnostics(merged, value, options);
+        return {
+            valid: mapResponse.valid && !hasErrors(merged),
+            diagnostics: merged,
+            ...(mapResponse.pkg === undefined ? {} : { pkg: mapResponse.pkg }),
+        };
+    }
+    const packageId = packageIdOf(family, value);
+    if (!packageId) {
+        diagnostics.push({
+            code: "missing-package-id",
+            severity: "error",
+            message: `${family} package must carry a non-empty identity field.`,
+            path: family === "dashboard" ? "appId" : family === "app" ? "id" : "packageId",
+        });
+    }
+    const expectedFormat = FAMILY_FORMAT[family];
+    if (expectedFormat !== undefined && family !== "app" && value.format !== expectedFormat) {
+        diagnostics.push({
+            code: "unsupported-format",
+            severity: "error",
+            message: `${family} package format must be "${expectedFormat}".`,
+            path: "format",
+            detail: { expected: expectedFormat, received: value.format },
+        });
+    }
+    appendLifecycleDiagnostics(diagnostics, value, options);
+    appendProvenanceDiagnostics(diagnostics, value, options);
+    return {
+        valid: !hasErrors(diagnostics),
+        diagnostics,
+        pkg: value,
+    };
+}
+/**
+ * Validate just the {@link HonuaPackageProvenance} envelope on a package value.
+ * Useful when a host (MCP/QGIS) wants to confirm attribution without running
+ * the full family validation.
+ *
+ * @experimental
+ */
+export function validatePackageProvenance(value, options = {}) {
+    const diagnostics = [];
+    appendProvenanceDiagnostics(diagnostics, value, { requireProvenance: options.required });
+    const provenance = getPackageProvenance(value);
+    return {
+        valid: !hasErrors(diagnostics),
+        diagnostics,
+        ...(provenance === undefined ? {} : { pkg: provenance }),
+    };
+}
+const KNOWN_ORIGINS = new Set(["console", "studio", "mcp", "qgis", "sdk"]);
+function appendProvenanceDiagnostics(diagnostics, value, options) {
+    const raw = isRecord(value) ? value.provenance : undefined;
+    if (raw === undefined) {
+        if (options.requireProvenance) {
+            diagnostics.push({
+                code: "missing-provenance",
+                severity: "error",
+                message: "Package provenance is required but absent.",
+                path: "provenance",
+            });
+        }
+        return;
+    }
+    if (!isRecord(raw)) {
+        diagnostics.push({
+            code: "invalid-provenance",
+            severity: "error",
+            message: "Package provenance must be a JSON object.",
+            path: "provenance",
+        });
+        return;
+    }
+    if (raw.format !== HONUA_PACKAGE_PROVENANCE_FORMAT_V1) {
+        diagnostics.push({
+            code: "unsupported-provenance-format",
+            severity: "error",
+            message: `Package provenance.format must be "${HONUA_PACKAGE_PROVENANCE_FORMAT_V1}".`,
+            path: "provenance.format",
+            detail: { expected: HONUA_PACKAGE_PROVENANCE_FORMAT_V1, received: raw.format },
+        });
+        return;
+    }
+    if (typeof raw.origin !== "string" || raw.origin.length === 0) {
+        diagnostics.push({
+            code: "missing-provenance-origin",
+            severity: "error",
+            message: "Package provenance.origin must be a non-empty string.",
+            path: "provenance.origin",
+        });
+    }
+    else if (!KNOWN_ORIGINS.has(raw.origin)) {
+        diagnostics.push({
+            code: "unknown-provenance-origin",
+            severity: "warning",
+            message: `Package provenance.origin "${raw.origin}" is not a known surface.`,
+            path: "provenance.origin",
+            detail: { origin: raw.origin, known: [...KNOWN_ORIGINS] },
+        });
+    }
+    if (raw.dataBindings !== undefined && !Array.isArray(raw.dataBindings)) {
+        diagnostics.push({
+            code: "invalid-provenance-data-bindings",
+            severity: "error",
+            message: "Package provenance.dataBindings must be an array when present.",
+            path: "provenance.dataBindings",
+        });
+    }
+    else if (Array.isArray(raw.dataBindings)) {
+        raw.dataBindings.forEach((binding, i) => {
+            if (!isRecord(binding) || typeof binding.sourceId !== "string" || binding.sourceId.length === 0) {
+                diagnostics.push({
+                    code: "invalid-provenance-data-binding",
+                    severity: "error",
+                    message: "Each provenance dataBinding must carry a non-empty sourceId.",
+                    path: `provenance.dataBindings[${i}].sourceId`,
+                });
+            }
+        });
+    }
+    if (raw.permissions !== undefined && !Array.isArray(raw.permissions)) {
+        diagnostics.push({
+            code: "invalid-provenance-permissions",
+            severity: "error",
+            message: "Package provenance.permissions must be an array when present.",
+            path: "provenance.permissions",
+        });
+    }
+    else if (Array.isArray(raw.permissions)) {
+        raw.permissions.forEach((permission, i) => {
+            if (!isRecord(permission) || typeof permission.scope !== "string" || permission.scope.length === 0) {
+                diagnostics.push({
+                    code: "invalid-provenance-permission",
+                    severity: "error",
+                    message: "Each provenance permission must carry a non-empty scope.",
+                    path: `provenance.permissions[${i}].scope`,
+                });
+            }
+        });
+    }
+}
+function appendLifecycleDiagnostics(diagnostics, value, options) {
+    const nowMs = options.now instanceof Date ? options.now.getTime() : (options.now ?? Date.now());
+    if (value.status === "Expired") {
+        diagnostics.push({
+            code: "expired-package",
+            severity: "error",
+            message: "Package status is Expired.",
+            path: "status",
+        });
+    }
+    const expiresAt = parseTimestamp(value.expiresAt);
+    if (expiresAt !== undefined && expiresAt <= nowMs) {
+        diagnostics.push({
+            code: "expired-package",
+            severity: "error",
+            message: "Package expiresAt is in the past.",
+            path: "expiresAt",
+        });
+    }
+}
+function parseTimestamp(value) {
+    if (typeof value !== "string" && typeof value !== "number")
+        return undefined;
+    const parsed = typeof value === "number" ? value : Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function hasErrors(diagnostics) {
+    return diagnostics.some((d) => d.severity === "error");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/studio/validation.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Unified validation and preview response envelopes shared across every
+ * Studio package family and across the SDK, Console, MCP, and QGIS clients.
+ *
+ * The existing {@link ValidateMapPackageResult} (map family) stays unchanged;
+ * {@link toStudioValidationResponse} and {@link fromMapPackageValidation}
+ * adapt it into the generic {@link StudioPackageValidationResponse} envelope
+ * without renaming or restructuring it. {@link HonuaMapPackageDiagnostic} is
+ * already a structural subtype of {@link StudioPackageDiagnostic}.
+ *
+ * @experimental Not yet covered by the SDK's semver contract — these shapes
+ *   may change in any minor release prior to `1.0.0`.
+ * @module
+ */
+import type { ValidateMapPackageResult } from "../runtime/map-package-validation.js";
+import type { HonuaMapPackage } from "../runtime/map-package.js";
+import type { HonuaStudioPackageFamily } from "./types.js";
+/**
+ * Severity of a single {@link StudioPackageDiagnostic}. Matches the frozen
+ * server / honua-sdk-dotnet `StudioPackageDiagnosticSeverity` enum members
+ * (`info`, `warning`, `error`, `blocker`); the map-package validator emits only
+ * `error`/`warning`, which remain assignable.
+ */
+export type StudioPackageDiagnosticSeverity = "info" | "warning" | "error" | "blocker";
+/**
+ * One diagnostic emitted while validating a Studio package. The shape is a
+ * superset-compatible mirror of `HonuaMapPackageDiagnostic` so the map
+ * validator's output adapts without conversion.
+ *
+ * @experimental
+ */
+export interface StudioPackageDiagnostic {
+    readonly code: string;
+    readonly severity: StudioPackageDiagnosticSeverity;
+    readonly message: string;
+    readonly path?: string;
+    readonly detail?: unknown;
+}
+/**
+ * Generic validation response envelope. Every package family returns the
+ * same `{ valid, diagnostics, pkg? }` shape, so SDK, Console, MCP, and QGIS
+ * clients consume one contract.
+ *
+ * @experimental
+ */
+export interface StudioPackageValidationResponse<T> {
+    readonly valid: boolean;
+    readonly diagnostics: readonly StudioPackageDiagnostic[];
+    readonly pkg?: T;
+}
+/** Reference to a server-rendered preview artifact for a package. */
+export interface StudioPreviewArtifactRef {
+    readonly id?: string;
+    readonly kind?: string;
+    readonly url?: string;
+    readonly mediaType?: string;
+    readonly [extra: string]: unknown;
+}
+/**
+ * Generic preview response envelope returned when a package is previewed
+ * (composed without publishing). Diagnostics reuse the validation shape.
+ *
+ * @experimental
+ */
+export interface StudioPackagePreviewResponse<T> {
+    readonly packageId?: string;
+    readonly packageFamily?: HonuaStudioPackageFamily | (string & {});
+    readonly pkg?: T;
+    readonly diagnostics?: readonly StudioPackageDiagnostic[];
+    readonly artifacts?: readonly StudioPreviewArtifactRef[];
+    readonly expiresAt?: string;
+    readonly [extra: string]: unknown;
+}
+/**
+ * Loose shape a family-specific validation result must satisfy to be adapted
+ * by {@link toStudioValidationResponse}. Diagnostics carry no index signature
+ * so that results with extra diagnostic fields (e.g. `packageId` on
+ * {@link HonuaMapPackageDiagnostic}) — and results that carry a named package
+ * field alongside `valid`/`diagnostics` — assign without a structural index
+ * signature on the caller's type.
+ */
+interface StudioValidationResultLike {
+    readonly valid: boolean;
+    readonly diagnostics: readonly {
+        readonly code: string;
+        readonly severity: StudioPackageDiagnosticSeverity;
+        readonly message: string;
+        readonly path?: string;
+        readonly detail?: unknown;
+    }[];
+}
+/**
+ * Adapt any family validation result — an object with `valid`, `diagnostics`,
+ * and a named package field — into the unified
+ * {@link StudioPackageValidationResponse}. `pkgKey` names the field holding
+ * the package (e.g. `"mapPackage"`). The package field is loosely typed; for
+ * the map family prefer the fully-typed {@link fromMapPackageValidation}.
+ *
+ * @experimental
+ */
+export declare function toStudioValidationResponse<T>(result: StudioValidationResultLike, pkgKey: string): StudioPackageValidationResponse<T>;
+/**
+ * Fully-typed convenience adapter from the map family's
+ * {@link ValidateMapPackageResult} to a
+ * {@link StudioPackageValidationResponse}. Equivalent to
+ * `toStudioValidationResponse<HonuaMapPackage>(result, "mapPackage")`.
+ *
+ * @experimental
+ */
+export declare function fromMapPackageValidation(result: ValidateMapPackageResult): StudioPackageValidationResponse<HonuaMapPackage>;
+export {};
+//# sourceMappingURL=validation.d.ts.map

package/studio/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/studio/validation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,sCAAsC,CAAC;AACrF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAE3D;;;;;GAKG;AACH,MAAM,MAAM,+BAA+B,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC;AAEvF;;;;;;GAMG;AACH,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,+BAA+B,CAAC;IACnD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,+BAA+B,CAAC,CAAC;IAChD,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,SAAS,uBAAuB,EAAE,CAAC;IACzD,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;CAClB;AAED,qEAAqE;AACrE,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;CACnC;AAED;;;;;GAKG;AACH,MAAM,WAAW,4BAA4B,CAAC,CAAC;IAC7C,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,aAAa,CAAC,EAAE,wBAAwB,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;IAClE,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IACjB,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,uBAAuB,EAAE,CAAC;IAC1D,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,wBAAwB,EAAE,CAAC;IACzD,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;CACnC;AAED;;;;;;;GAOG;AACH,UAAU,0BAA0B;IAClC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,SAAS;QAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,QAAQ,EAAE,+BAA+B,CAAC;QACnD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QACzB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;KAC3B,EAAE,CAAC;CACL;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,EAC1C,MAAM,EAAE,0BAA0B,EAClC,MAAM,EAAE,MAAM,GACb,+BAA+B,CAAC,CAAC,CAAC,CAOpC;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,wBAAwB,GAC/B,+BAA+B,CAAC,eAAe,CAAC,CAElD"}

package/studio/validation.js

@@ -0,0 +1,42 @@
+/**
+ * Unified validation and preview response envelopes shared across every
+ * Studio package family and across the SDK, Console, MCP, and QGIS clients.
+ *
+ * The existing {@link ValidateMapPackageResult} (map family) stays unchanged;
+ * {@link toStudioValidationResponse} and {@link fromMapPackageValidation}
+ * adapt it into the generic {@link StudioPackageValidationResponse} envelope
+ * without renaming or restructuring it. {@link HonuaMapPackageDiagnostic} is
+ * already a structural subtype of {@link StudioPackageDiagnostic}.
+ *
+ * @experimental Not yet covered by the SDK's semver contract — these shapes
+ *   may change in any minor release prior to `1.0.0`.
+ * @module
+ */
+/**
+ * Adapt any family validation result — an object with `valid`, `diagnostics`,
+ * and a named package field — into the unified
+ * {@link StudioPackageValidationResponse}. `pkgKey` names the field holding
+ * the package (e.g. `"mapPackage"`). The package field is loosely typed; for
+ * the map family prefer the fully-typed {@link fromMapPackageValidation}.
+ *
+ * @experimental
+ */
+export function toStudioValidationResponse(result, pkgKey) {
+    const pkg = result[pkgKey];
+    return {
+        valid: result.valid,
+        diagnostics: [...result.diagnostics],
+        ...(pkg === undefined ? {} : { pkg: pkg }),
+    };
+}
+/**
+ * Fully-typed convenience adapter from the map family's
+ * {@link ValidateMapPackageResult} to a
+ * {@link StudioPackageValidationResponse}. Equivalent to
+ * `toStudioValidationResponse<HonuaMapPackage>(result, "mapPackage")`.
+ *
+ * @experimental
+ */
+export function fromMapPackageValidation(result) {
+    return toStudioValidationResponse(result, "mapPackage");
+}

package/style/factory.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Style-to-source factory: creates Honua SDK surface instances from a
+ * HonuaStyleSpecification's source definitions.
+ *
+ * @module
+ */
+import type { HonuaClient } from "../core/client.js";
+import { HonuaFeatureLayer, HonuaMapService, type HonuaOgcFeatureCollection } from "../core/surfaces.js";
+import type { HonuaWms, HonuaWmsLayer } from "../core/wms.js";
+import type { HonuaWmts, HonuaWmtsTileset } from "../core/wmts.js";
+import type { HonuaStyleSpecification } from "./specification.js";
+/** A resolved Honua source: either a surface instance or `null` for non-Honua (MapLibre-native) sources. */
+export type ResolvedSource = HonuaFeatureLayer | HonuaMapService | HonuaOgcFeatureCollection | HonuaWms | HonuaWmsLayer | HonuaWmts | HonuaWmtsTileset | null;
+/**
+ * Create Honua SDK surface instances for each source in a style.
+ *
+ * Non-Honua sources (e.g. `vector`, `raster`, `geojson`) are mapped to `null` —
+ * these should be handled directly by MapLibre's built-in source types.
+ *
+ * @example
+ * ```ts
+ * const sources = createSources(client, style);
+ * const parcels = sources.get("parcels"); // HonuaFeatureLayer
+ * if (parcels instanceof HonuaFeatureLayer) {
+ *   const features = await parcels.queryFeatures({ where: "status = 'active'" });
+ * }
+ * ```
+ */
+export declare function createSources(client: HonuaClient, style: HonuaStyleSpecification): Map<string, ResolvedSource>;
+//# sourceMappingURL=factory.d.ts.map

package/style/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/style/factory.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,KAAK,yBAAyB,EAE/B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAEnE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAWlE,4GAA4G;AAC5G,MAAM,MAAM,cAAc,GACtB,iBAAiB,GACjB,eAAe,GACf,yBAAyB,GACzB,QAAQ,GACR,aAAa,GACb,SAAS,GACT,gBAAgB,GAChB,IAAI,CAAC;AAET;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,uBAAuB,GAAG,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAsC9G"}

package/style/factory.js

@@ -0,0 +1,61 @@
+/**
+ * Style-to-source factory: creates Honua SDK surface instances from a
+ * HonuaStyleSpecification's source definitions.
+ *
+ * @module
+ */
+import { HonuaFeatureLayer, HonuaMapService, HonuaOgcFeatures, } from "../core/surfaces.js";
+import { parseFeatureLayerUrl, parseMapServiceUrl } from "../esri-compat/url.js";
+import { isFeatureServiceSource, isMapServiceSource, isOgcFeaturesSource, isWmsSource, isWmtsSource, parseOgcFeaturesUrl, } from "./specification.js";
+import { resolveWmsSpec, resolveWmtsSpec } from "./wms-wmts-resolvers.js";
+/**
+ * Create Honua SDK surface instances for each source in a style.
+ *
+ * Non-Honua sources (e.g. `vector`, `raster`, `geojson`) are mapped to `null` —
+ * these should be handled directly by MapLibre's built-in source types.
+ *
+ * @example
+ * ```ts
+ * const sources = createSources(client, style);
+ * const parcels = sources.get("parcels"); // HonuaFeatureLayer
+ * if (parcels instanceof HonuaFeatureLayer) {
+ *   const features = await parcels.queryFeatures({ where: "status = 'active'" });
+ * }
+ * ```
+ */
+export function createSources(client, style) {
+    const result = new Map();
+    for (const [name, spec] of Object.entries(style.sources)) {
+        if (isFeatureServiceSource(spec)) {
+            const parsed = parseFeatureLayerUrl(spec.url);
+            result.set(name, new HonuaFeatureLayer({
+                client,
+                serviceId: parsed.serviceId,
+                layerId: parsed.layerId,
+            }));
+        }
+        else if (isMapServiceSource(spec)) {
+            const parsed = parseMapServiceUrl(spec.url);
+            result.set(name, new HonuaMapService({
+                client,
+                serviceId: parsed.serviceId,
+            }));
+        }
+        else if (isOgcFeaturesSource(spec)) {
+            const parsed = parseOgcFeaturesUrl(spec.url);
+            const ogcRoot = new HonuaOgcFeatures({ client });
+            const collectionId = spec.collectionId ?? parsed.collectionId ?? "";
+            result.set(name, ogcRoot.collection(collectionId));
+        }
+        else if (isWmsSource(spec)) {
+            result.set(name, resolveWmsSpec(client, spec));
+        }
+        else if (isWmtsSource(spec)) {
+            result.set(name, resolveWmtsSpec(client, spec));
+        }
+        else {
+            result.set(name, null);
+        }
+    }
+    return result;
+}

package/style/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * `@honua/sdk-js/style` — Honua style spec source parsers and validators.
+ *
+ * Translate `Source`/`SourceDescriptor` shapes to and from MapLibre-style
+ * source specifications, and validate Honua style documents.
+ *
+ * @example
+ * ```ts
+ * import { createSources, validateHonuaStyle, parseOgcFeaturesUrl } from "@honua/sdk-js/style";
+ *
+ * const sources = createSources(dataset.sourceDescriptors);
+ * const errors = validateHonuaStyle(myStyle);
+ * if (errors.length) throw new Error(errors.map(e => e.message).join("\n"));
+ *
+ * const parsed = parseOgcFeaturesUrl("https://example.com/ogc/collections/parcels/items");
+ * console.log(parsed.collectionId); // "parcels"
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { isHonuaSource, isFeatureServiceSource, isMapServiceSource, isOgcFeaturesSource, isWmsSource, isWmtsSource, parseOgcFeaturesUrl, validateHonuaStyle, } from "./specification.js";
+export type { HonuaSourceBase, HonuaFeatureServiceSourceSpecification, HonuaMapServiceSourceSpecification, HonuaOgcFeaturesSourceSpecification, HonuaWmsSourceSpecification, HonuaWmtsSourceSpecification, HonuaSourceSpecification, HonuaLayerSpecification, HonuaStyleSpecification, ParsedOgcFeaturesUrl, StyleValidationError, } from "./specification.js";
+export { createSources } from "./factory.js";
+export type { ResolvedSource } from "./factory.js";
+//# sourceMappingURL=index.d.ts.map

package/style/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/style/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EACL,aAAa,EACb,sBAAsB,EACtB,kBAAkB,EAClB,mBAAmB,EACnB,WAAW,EACX,YAAY,EACZ,mBAAmB,EACnB,kBAAkB,GACnB,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EACV,eAAe,EACf,sCAAsC,EACtC,kCAAkC,EAClC,mCAAmC,EACnC,2BAA2B,EAC3B,4BAA4B,EAC5B,wBAAwB,EACxB,uBAAuB,EACvB,uBAAuB,EACvB,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC"}

package/style/index.js

@@ -0,0 +1,24 @@
+/**
+ * `@honua/sdk-js/style` — Honua style spec source parsers and validators.
+ *
+ * Translate `Source`/`SourceDescriptor` shapes to and from MapLibre-style
+ * source specifications, and validate Honua style documents.
+ *
+ * @example
+ * ```ts
+ * import { createSources, validateHonuaStyle, parseOgcFeaturesUrl } from "@honua/sdk-js/style";
+ *
+ * const sources = createSources(dataset.sourceDescriptors);
+ * const errors = validateHonuaStyle(myStyle);
+ * if (errors.length) throw new Error(errors.map(e => e.message).join("\n"));
+ *
+ * const parsed = parseOgcFeaturesUrl("https://example.com/ogc/collections/parcels/items");
+ * console.log(parsed.collectionId); // "parcels"
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { isHonuaSource, isFeatureServiceSource, isMapServiceSource, isOgcFeaturesSource, isWmsSource, isWmtsSource, parseOgcFeaturesUrl, validateHonuaStyle, } from "./specification.js";
+export { createSources } from "./factory.js";
+// Feature Service and Map Service URL parsers are exported from
+// esri-compat/url.ts via the main index.ts barrel — no re-export needed here.