@call-me-sensei/toonlab 0.3.1 → 0.4.20

package/types/sky/timeOfDay.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Folds any day time onto [0, 1); 0 is midnight, 0.5 noon.
+ *
+ * In-range values pass through untouched. The modulo route is not exact —
+ * ((0.85 % 1) + 1) % 1 lands on 0.8500000000000001 — and this runs on every
+ * tick and every applyParams, so an authored preset time would drift away from
+ * the number the author typed and break round-trip identity.
+ *
+ * `fallback` is what an unreadable time resolves to. Anything holding clock
+ * state must pass the reading it wants to keep (see `createTimeOfDay`), because
+ * landing on the factory default would jump the whole sky to noon. The
+ * factory-default fallback is only for one-shot solves like `sunDirectionAt`,
+ * which have no previous reading to hold.
+ */
+export function wrapDayTime(time: any, fallback?: 0.5): any;
+/**
+ * Phase terms a shaded moon disc needs, from the 0..1 phase dial.
+ *
+ * `illumination` is the lit fraction of the disc, (1 + cos ψ) / 2 for the
+ * phase angle ψ = π(1 − 2·phase) — the fraction astronomy quotes, so a
+ * quarter moon reads 0.5 and a new moon 0. Every moonshine term (disc, sky
+ * ambient, cloud rim) scales by it, which is what keeps a sliver dim.
+ *
+ * `sin`/`cos` are that angle's trig, signed so waxing and waning light
+ * opposite limbs. They hand the disc shader its sub-solar direction in disc
+ * space, `vec3(sin, 0, cos)` with +x along the disc's tangent axis and +z
+ * toward the viewer: a fragment is lit where dot(discNormal, that) > 0. The
+ * terminator is fixed in disc space on purpose — the moon here is exactly
+ * antipodal to the sun, so a geometric phase would always be new, and the
+ * phase dial is an authored look, not a position.
+ */
+export function moonPhaseTerms(phase: any, target?: {
+    illumination: number;
+    sin: number;
+    cos: number;
+}): {
+    illumination: number;
+    sin: number;
+    cos: number;
+};
+/**
+ * Builds the clock. Pass any subset of TimeOfDayParams; the rest defaults.
+ *
+ * Driven uniforms (`moonDirection`, `skyDarkness`, `morningLight`,
+ * `eveningLight`, `starRotation`, `moonPhaseIllumination`, `moonPhaseTrig`) are
+ * declared here so materials can
+ * bind them at build time. The three that need the celestial solve hold neutral
+ * values until the first driver tick, which happens when the driver is
+ * constructed; the two moon-phase terms are pure functions of `moonPhase`, so
+ * this module keeps them correct from construction on — an env-map bake before
+ * the driver exists must not light a new moon like a full one.
+ */
+export function createTimeOfDay(params?: {}): {
+    time: import("three/webgpu").UniformNode<"float", number>;
+    moonPhase: import("three/webgpu").UniformNode<"float", number>;
+    moonIntensity: import("three/webgpu").UniformNode<"float", number>;
+    moonDiscBrightness: import("three/webgpu").UniformNode<"float", number>;
+    moonAngularSize: import("three/webgpu").UniformNode<"float", number>;
+    moonColor: import("three/webgpu").UniformNode<"color", THREE.Color>;
+    moonAmbient: import("three/webgpu").UniformNode<"float", number>;
+    moonDirection: import("three/webgpu").UniformNode<"vec3", THREE.Vector3>;
+    skyDarkness: import("three/webgpu").UniformNode<"float", number>;
+    morningLight: import("three/webgpu").UniformNode<"float", number>;
+    eveningLight: import("three/webgpu").UniformNode<"float", number>;
+    starRotation: import("three/webgpu").UniformNode<"mat3", THREE.Matrix3>;
+    moonPhaseIllumination: import("three/webgpu").UniformNode<"float", number>;
+    moonPhaseTrig: import("three/webgpu").UniformNode<"vec2", THREE.Vector2>;
+    /** Real seconds one simulated day takes. 0 pauses, which also releases sun.direction. */
+    autoAdvanceSecondsPerDay: 600;
+    /** Observer latitude in degrees, clamped to −90…90. Tilts the arcs and the star pole. */
+    latitude: 45;
+    /** Compass rotation of the whole celestial sphere, degrees. 0 = +Z, 90 = +X. */
+    azimuth: 0;
+    /**
+     * Folds a host's direct `time.value` scrub back onto [0, 1) and returns it.
+     *
+     * The driver calls this once per tick, which is what makes
+     * `timeOfDay.time.value = 0.85` a supported host path. An unreadable value
+     * resolves to the last readable reading, not to the factory default: a bad
+     * write should be ignored, not teleport the clock to noon.
+     */
+    foldTime(): 0.5;
+    applyParams(next?: {}): void;
+    toParams(): {
+        time: any;
+        autoAdvanceSecondsPerDay: 600;
+        latitude: 45;
+        azimuth: 0;
+        moon: {
+            phase: number;
+            intensity: number;
+            discBrightness: number;
+            angularSize: number;
+            color: THREE.Color;
+            ambient: number;
+        };
+    };
+};
+export const DEFAULT_MOON_PARAMS: Readonly<{
+    phase: 0.5;
+    intensity: 1;
+    discBrightness: 9;
+    angularSize: 0.0003;
+    color: readonly number[];
+    ambient: 0.015;
+}>;
+export const DEFAULT_TIME_OF_DAY_PARAMS: Readonly<{
+    time: 0.5;
+    autoAdvanceSecondsPerDay: 600;
+    latitude: 45;
+    azimuth: 0;
+    moon: Readonly<{
+        phase: 0.5;
+        intensity: 1;
+        discBrightness: 9;
+        angularSize: 0.0003;
+        color: readonly number[];
+        ambient: 0.015;
+    }>;
+}>;
+/**
+ * The `time.moon.color` descriptor, published here rather than in the SkyParams
+ * envelope for the reason its sibling `sun.color` is published by sunDriver.js:
+ * this module clamps the live colour to it on every applyParams and the envelope
+ * declares the same field, so the channel maximum has one definition instead of
+ * one per layer. Emissive like the sun tint, so it keeps its HDR headroom.
+ */
+export const MOON_COLOR_FIELD: Readonly<{
+    derived: false;
+    derive: any;
+    description: any;
+    fold: any;
+    integer: false;
+    label: any;
+    limit: Readonly<{
+        max: any;
+        min: 0;
+    }>;
+    type: "color";
+    unit: "linear RGB";
+    uniform: boolean;
+    value: readonly any[];
+    wrap: any;
+}>;
+import * as THREE from 'three';

package/types/styles/animeGameProfile.d.ts

@@ -0,0 +1,27 @@
+export function cloneAnimeGameProfile(profile?: Readonly<{
+    antiGoals: readonly any[];
+    family: "anime-game";
+    rendering: "cel-shaded";
+    subjects: readonly any[];
+    traits: readonly any[];
+}>): {
+    antiGoals: any[];
+    family: "anime-game";
+    rendering: "cel-shaded";
+    subjects: any[];
+    traits: any[];
+};
+/**
+ * Public product intent shared by style bundles, MCP discovery, and coding
+ * agents. ToonLab is intentionally narrower than a generic "stylized" kit.
+ */
+export const TOONLAB_ANIME_GAME_PROFILE: Readonly<{
+    antiGoals: readonly any[];
+    family: "anime-game";
+    rendering: "cel-shaded";
+    subjects: readonly any[];
+    traits: readonly any[];
+}>;
+export const TOONLAB_ANIME_GAME_PROFILE_FAMILY: "anime-game";
+export const TOONLAB_ANIME_GAME_RENDERING: "cel-shaded";
+export const DEFAULT_UNSUPPORTED_STYLE_DOMAINS: readonly any[];

package/types/styles/index.d.ts

@@ -0,0 +1,18 @@
+export { createSceneStyleRuntime } from "./sceneStyleRuntime.js";
+export { CALL_ME_SENSEI_STYLE_BUNDLE, CALL_ME_SENSEI_STYLE_SLOT_IDS, createStyleBundleDocument, DEFAULT_STYLE_BUNDLE_BASE_URL, fetchStyleBundle, FIRST_PARTY_STYLE_BUNDLES, getFirstPartyStyleBundle, LEGACY_STYLE_BUNDLE_SCHEMA_VERSION, listFirstPartyStyleBundles, migrateStyleBundleDocument, parseStyleBundleDocument, resolveStyleBundleSettings, serializeStyleBundle, STYLE_BUNDLE_DOCUMENT_TYPE, STYLE_BUNDLE_SCHEMA_VERSION, STYLE_BUNDLE_SLOT_IDS, STYLE_BUNDLE_SLOTS, validateStyleBundleDocument } from "./styleBundle.js";
+export { cloneAnimeGameProfile, DEFAULT_UNSUPPORTED_STYLE_DOMAINS, TOONLAB_ANIME_GAME_PROFILE, TOONLAB_ANIME_GAME_PROFILE_FAMILY, TOONLAB_ANIME_GAME_RENDERING } from "./animeGameProfile.js";
+export { applyStyleBundle, auditStyleBundleApplication, STYLE_DOMAIN_SLOT_ROUTES, STYLE_TARGET_DOMAINS, StyleBundleApplicationError, StyleBundleTransactionError } from "./styleApplication.js";
+export { captureStyleTargetSnapshot, restoreStyleTargetSnapshot } from "./styleTransaction.js";
+export { BUILT_IN_STYLE_ADAPTERS, createStyleTarget, resolveStyleTargetAdapter } from "./styleAdapters.js";
+export { createToonLabInspector, TOONLAB_INSPECTOR_DOCUMENT_TYPE, TOONLAB_INSPECTOR_VERSION, ToonLabInspectorToggleError } from "./styleInspector.js";
+export { createStyleTargetLabel, migrateStyleTargetLabel, parseStyleTargetLabel, serializeStyleTargetLabel, STYLE_TARGET_LABEL_KEY, STYLE_TARGET_LABEL_SCHEMA_VERSION, validateStyleTargetLabel } from "./styleTargetLabels.js";
+export { createStyleMaterialContract, parseStyleMaterialContract, serializeStyleMaterialContract, STYLE_DOMAIN_MATERIAL_ROLES, STYLE_MATERIAL_CONTRACT_SCHEMA_VERSION, STYLE_MATERIAL_EXEMPTION_STRATEGIES, STYLE_MATERIAL_MASK_ENCODINGS, STYLE_MATERIAL_STABLE_ID_PATTERN, validateStyleMaterialContract } from "./styleMaterialContract.js";
+export { collectStyleTargets, labelStyleTarget, readStyleTargetLabel, removeStyleTargetLabel, StyleTargetDiscoveryError, StyleTargetLabelError } from "./styleTargetDiscovery.js";
+export { applyManufacturedStyleTargetLabelProposal, labelManufacturedStyleTarget, ManufacturedStyleLabelingError, proposeManufacturedStyleTargetLabel } from "./manufacturedStyleLabeling.js";
+export { auditSceneStyleContract, serializeSceneStyleAudit, STYLE_SCENE_AUDIT_DOCUMENT_TYPE, STYLE_SCENE_AUDIT_MODES, STYLE_SCENE_AUDIT_SCHEMA_VERSION } from "./sceneStyleAudit.js";
+export { createSceneContentDocument, createSceneOverrideDocument, createSceneQualityDocument, createSceneScenarioDocument, parseSceneContentDocument, parseSceneOverrideDocument, parseSceneQualityDocument, parseSceneScenarioDocument, SCENE_CONTENT_DOCUMENT_TYPE, SCENE_LAYER_DOCUMENT_VERSION, SCENE_OVERRIDE_DOCUMENT_TYPE, SCENE_QUALITY_DOCUMENT_TYPE, SCENE_SCENARIO_DOCUMENT_TYPE, serializeSceneContentDocument, serializeSceneOverrideDocument, serializeSceneQualityDocument, serializeSceneScenarioDocument, validateSceneContentDocument, validateSceneOverrideDocument, validateSceneQualityDocument, validateSceneScenarioDocument } from "./sceneLayerDocuments.js";
+export { RESOLVED_SCENE_LOOK_DOCUMENT_TYPE, RESOLVED_SCENE_LOOK_DOCUMENT_VERSION, resolveSceneLook, SceneLookCompositionError, serializeResolvedSceneLook } from "./sceneLookComposition.js";
+export { SceneQualityApplicationError, applySceneQualityProfile } from "./sceneQualityApplication.js";
+export { STYLE_BUNDLE_PROVIDER_VERSION, createOssStyleBundleProvider, createStyleBundleProvider, createUserStyleBundleProvider, resolveStyleBundleSelection } from "./styleBundleProvider.js";
+export { SCENE_QUALITY_PROFILES, SCENE_QUALITY_PROFILE_VERSION, createSceneQualityProfile, getSceneQualityProfileOptions, parseSceneQualityProfile, resolveCatalogQualityOptions, resolveSceneQualityProfile, resolveSkyQualityOptions, resolveVegetationQualityOptions, resolveWaterQualityOptions, serializeSceneQualityProfile, validateSceneQualityProfile } from "./sceneQualityProfiles.js";
+export { NEUTRAL_ENVIRONMENT_PRESET, NEUTRAL_ENVIRONMENT_RESOLVED_SETTINGS, NEUTRAL_GRASS_SETTINGS, NEUTRAL_GROUND_SHADER_SETTINGS, NEUTRAL_MANUFACTURED_SURFACE_DOCUMENT, NEUTRAL_MANUFACTURED_SURFACE_RESOLVED_SETTINGS, NEUTRAL_MANUFACTURED_SURFACE_SETTINGS, NEUTRAL_POST_SETTINGS, NEUTRAL_SKY_SETTINGS, NEUTRAL_STYLE_BUNDLE, NEUTRAL_STYLE_NON_SHADING_KEYS, NEUTRAL_STYLE_PRESET_ID, NEUTRAL_STYLE_SLOT_COVERAGE, NEUTRAL_STYLE_SLOT_IDS, NEUTRAL_TOON_RESOLVED_SETTINGS, NEUTRAL_TOON_SETTINGS, NEUTRAL_VEGETATION_SHADER_SETTINGS, NEUTRAL_WATER_STYLE, auditNeutralStyleShadingOnly, describeNeutralStyleCoverage, registerNeutralStylePresets } from "./neutralStylePresets.js";

package/types/styles/manufacturedStyleLabeling.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Build a conservative, read-only label proposal for an imported manufactured
+ * asset. Low-confidence and generic fallback classifications remain explicit
+ * blockers until an agent/developer supplies an override.
+ */
+export function proposeManufacturedStyleTargetLabel(root: any, { assetId, confidenceThreshold, materialOverrides, targetId, }?: {
+    assetId?: any;
+    confidenceThreshold?: number;
+    materialOverrides?: {};
+    targetId?: any;
+}): {
+    analysis: {
+        assetId: any;
+        objectClass: any;
+        records: any[];
+        summary: {
+            explicitCount: number;
+            fallbackCount: number;
+            inferredCount: number;
+            lowConfidenceCount: number;
+            materialUseCount: number;
+            uniqueMaterialCount: number;
+        };
+        warnings: string[];
+    };
+    assetId: any;
+    entries: {
+        classification: any;
+        material: any;
+        materialId: any;
+        useCount: any;
+    }[];
+    issues: ({
+        code: string;
+        materialId: any;
+        message: string;
+    } | {
+        code: string;
+        message: string;
+        materialId?: undefined;
+    })[];
+    label: {
+        extensions?: any;
+        materials?: any;
+        collision?: any;
+        domain: any;
+        assetId?: string;
+        targetId?: string;
+        schemaVersion: number;
+    };
+    objectClass: any;
+    ready: boolean;
+    summary: {
+        autoResolvedMaterials: number;
+        materialCount: number;
+        overrideCount: number;
+        unresolvedCount: number;
+    };
+    targetId: any;
+};
+/** Apply a previously reviewed proposal. No mutation occurs for a blocked proposal. */
+export function applyManufacturedStyleTargetLabelProposal(root: any, proposal: any, { replace }?: {
+    replace?: boolean;
+}): any;
+/** Propose and apply only when every live material is production-safe. */
+export function labelManufacturedStyleTarget(root: any, options?: {}): {
+    analysis: {
+        assetId: any;
+        objectClass: any;
+        records: any[];
+        summary: {
+            explicitCount: number;
+            fallbackCount: number;
+            inferredCount: number;
+            lowConfidenceCount: number;
+            materialUseCount: number;
+            uniqueMaterialCount: number;
+        };
+        warnings: string[];
+    };
+    assetId: any;
+    entries: {
+        classification: any;
+        material: any;
+        materialId: any;
+        useCount: any;
+    }[];
+    issues: ({
+        code: string;
+        materialId: any;
+        message: string;
+    } | {
+        code: string;
+        message: string;
+        materialId?: undefined;
+    })[];
+    label: {
+        extensions?: any;
+        materials?: any;
+        collision?: any;
+        domain: any;
+        assetId?: string;
+        targetId?: string;
+        schemaVersion: number;
+    };
+    objectClass: any;
+    ready: boolean;
+    summary: {
+        autoResolvedMaterials: number;
+        materialCount: number;
+        overrideCount: number;
+        unresolvedCount: number;
+    };
+    targetId: any;
+};
+export class ManufacturedStyleLabelingError extends Error {
+    constructor(proposal: any);
+    proposal: any;
+}