@zergai/ztc 0.4.0-beta.1 → 0.5.0-beta.1

package/dist/simulation/living/definer.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { type LivingInference } from './inference.js';
+import { kindRequestSchema, type LivingKindDefinition } from './open-world.js';
+export declare const kindDefinitionResponseSchema: Readonly<Record<string, unknown>>;
+export declare const DEFINER_SYSTEM: string;
+export declare const DEFINER_CALLS = 3;
+export declare function defineLivingKind(options: {
+    request: z.infer<typeof kindRequestSchema>;
+    existing: readonly LivingKindDefinition[];
+    inference: LivingInference;
+    stillWanted?: () => boolean;
+}): Promise<LivingKindDefinition>;

package/dist/simulation/living/definer.js

@@ -0,0 +1,223 @@
+import { z } from 'zod';
+import { WORLD_PRINCIPLES } from './context.js';
+import { kindFirst, responseFieldLines } from './inference.js';
+import { kindDefinitionSchema, valueMatchesType } from './open-world.js';
+import { assertLivingModelCall, LIVING_INPUT_BUDGETS } from './model-input.js';
+import { LivingWorldError } from './types.js';
+// What each mechanic means, shown beside its settings.
+const MECHANIC_MEANINGS = {
+    spread: 'propertyId, a level, moves along relationId, weaker with each step.',
+    signal: 'While propertyId is set, people where relationId points perceive it on channel, such as sight, sound, smell or touch.',
+    change: 'propertyId, a number, changes by deltaPerMinute; or, with deltaPerMinute 0 and onEvent, takes its value when the one its id property subjectPropertyId names moves.',
+    trigger: 'When propertyId, a number, crosses threshold in direction, the happening in intent follows after delayMinutes, at least minImportance.',
+    gate: 'While propertyId holds (at least atLeast when it is a level), the one its id property subjectPropertyId names cannot take blockedActionKinds.',
+    norm: 'actionKind is forbidden for roleId, or for everyone when null; breaking it is a norm violation.',
+    authority: 'roleId may change propertyId or relationId on others.',
+};
+function modelKindSchema() {
+    const schema = structuredClone(z.toJSONSchema(kindDefinitionSchema));
+    const { mechanics, ...slots } = schema.properties;
+    const items = mechanics.items;
+    const shapes = (items.anyOf ?? items.oneOf ?? []).map(shape => kindFirst('settings')({ required: shape.required,
+        properties: { ...shape.properties, kind: { ...shape.properties.kind, description: MECHANIC_MEANINGS[shape.properties.kind.const] } } }));
+    return { ...schema, properties: { ...slots, rules: { type: 'array', description: mechanics.description, items: { anyOf: shapes } } },
+        required: [...schema.required.filter(name => name !== 'mechanics'), 'rules'] };
+}
+function fromModelKind(answer) {
+    if (answer === null || typeof answer !== 'object' || Array.isArray(answer))
+        return answer;
+    const { rules, ...rest } = answer;
+    if (!Array.isArray(rules))
+        return answer;
+    return { ...rest, mechanics: rules.map(rule => {
+            if (rule === null || typeof rule !== 'object' || Array.isArray(rule))
+                return rule;
+            const { settings, ...named } = rule;
+            return settings !== null && typeof settings === 'object' && !Array.isArray(settings) ? { ...settings, ...named } : rule;
+        }) };
+}
+export const kindDefinitionResponseSchema = modelKindSchema();
+export const DEFINER_SYSTEM = `Role:
+You define one reusable kind for a living world. Include only properties, relations, and automatic mechanics needed for its general meaning.
+Principles:
+${WORLD_PRINCIPLES}
+Fields:
+${responseFieldLines(kindDefinitionResponseSchema)}
+Example:
+{"id":"new-kind","meaning":"A general thing.","name":"New kind","properties":[],"relations":[],"rules":[]}`;
+function responseSchemaFor(request, existing) {
+    const schema = structuredClone(kindDefinitionResponseSchema);
+    const properties = schema.properties;
+    const relations = properties.relations;
+    relations.items.properties.targetKindId.enum = [request.id, ...existing.map(kind => kind.id)];
+    return schema;
+}
+// A definition spends at most this many model requests, counting transport retries.
+export const DEFINER_CALLS = 3;
+// These bound one call's context, never the kinds retained in the world or library.
+const DEFINER_KIND_WINDOW = 32;
+const DEFINER_EXISTING_BUDGET = 6_000;
+const DEFINER_ERROR_BUDGET = 2_000;
+function definitionContext(existing) {
+    const selected = [];
+    let spent = 0;
+    for (let index = existing.length - 1; index >= 0 && selected.length < DEFINER_KIND_WINDOW; index -= 1) {
+        const kind = existing[index];
+        const size = JSON.stringify({ id: kind.id, meaning: kind.meaning }).length + 1;
+        if (spent + size > DEFINER_EXISTING_BUDGET)
+            continue;
+        selected.push(kind);
+        spent += size;
+    }
+    return selected.reverse();
+}
+export async function defineLivingKind(options) {
+    if (options.existing.some(kind => kind.id === options.request.id))
+        throw new LivingWorldError('inference-invalid', 'The requested kind already exists');
+    const existing = definitionContext(options.existing);
+    let previousErrors = [];
+    let spent = 0;
+    const reserveRetry = () => {
+        if (spent >= DEFINER_CALLS)
+            return false;
+        spent += 1;
+        return true;
+    };
+    for (let attempt = 0; attempt < DEFINER_CALLS && reserveRetry(); attempt += 1) {
+        // The authored request is indivisible. Spend the remaining serialized budget on repair and context.
+        const selected = [...existing];
+        const errors = [...previousErrors];
+        const input = () => ({ request: options.request, existing: selected.map(kind => ({ id: kind.id, meaning: kind.meaning })),
+            ...(errors.length ? { previousErrors: errors } : {}) });
+        while (JSON.stringify(input()).length > LIVING_INPUT_BUDGETS.define && selected.length > 0)
+            selected.shift();
+        while (JSON.stringify(input()).length > LIVING_INPUT_BUDGETS.define && errors.length > 0) {
+            const last = errors.pop();
+            const room = LIVING_INPUT_BUDGETS.define - JSON.stringify(input()).length - 30;
+            if (room > 2) {
+                let end = Math.min(last.length, room);
+                while (end > 0 && JSON.stringify(last.slice(0, end)).length > room)
+                    end -= 1;
+                if (end > 0)
+                    errors.push(last.slice(0, end));
+            }
+        }
+        const call = { reserveRetry,
+            role: 'definer', phase: 'define', system: DEFINER_SYSTEM,
+            input: input(),
+            responseSchema: responseSchemaFor(options.request, selected),
+            maxTokens: 700, timeoutMs: 45_000, ...(options.stillWanted ? { stillWanted: options.stillWanted } : {}),
+        };
+        assertLivingModelCall(call);
+        const answer = await options.inference.complete(call);
+        const problems = definitionProblems(fromModelKind(answer), options.request, existing);
+        if (problems.length === 0)
+            return kindDefinitionSchema.parse(fromModelKind(answer));
+        if (spent >= DEFINER_CALLS) {
+            // The last try keeps whatever part of the kind holds, so a new kind of thing still lasts.
+            const kept = soundPart(fromModelKind(answer), options.request, existing);
+            if (kept !== null)
+                return kept;
+            throw new LivingWorldError('inference-invalid', `The definer returned an invalid kind: ${problems.join('; ')}`);
+        }
+        // The next try receives bounded feedback about rejected fields and rules.
+        let remaining = DEFINER_ERROR_BUDGET;
+        previousErrors = problems.flatMap(problem => {
+            if (remaining <= 0)
+                return [];
+            const kept = problem.slice(0, remaining);
+            remaining -= kept.length;
+            return [kept];
+        });
+    }
+    throw new LivingWorldError('inference-invalid', 'The definer could not make a valid kind');
+}
+// What is wrong with one rule of a kind, naming the slots at fault.
+function ruleProblems(mechanic, definition) {
+    const problems = [];
+    const typeOf = (id) => definition.properties.find(property => property.id === id)?.type;
+    const relations = new Set(definition.relations.map(relation => relation.id));
+    const on = 'propertyId' in mechanic && mechanic.propertyId !== null ? mechanic.propertyId : null;
+    const onType = on === null ? undefined : typeOf(on);
+    if (on !== null && onType === undefined)
+        problems.push(`${mechanic.kind} rule names unknown property ${on}`);
+    if ('relationId' in mechanic && mechanic.relationId !== null && !relations.has(mechanic.relationId))
+        problems.push(`${mechanic.kind} rule names unknown relation ${mechanic.relationId}`);
+    if (mechanic.kind === 'authority' && (mechanic.propertyId === null) === (mechanic.relationId === null))
+        problems.push(`authority rule for ${mechanic.roleId} needs exactly one of propertyId or relationId`);
+    if (mechanic.kind === 'spread' && onType !== undefined && onType !== 'level')
+        problems.push(`spread rule on ${on}: it must be a level property, not ${onType}`);
+    if (mechanic.kind === 'trigger' && onType !== undefined && onType !== 'number')
+        problems.push(`trigger rule on ${on}: it must be a number property, not ${onType}`);
+    if (mechanic.kind === 'change' && !mechanic.onEvent && onType !== undefined && onType !== 'number')
+        problems.push(`change rule on ${on}: it must be a number property, not ${onType}`);
+    if (mechanic.kind === 'change' && mechanic.onEvent) {
+        if (mechanic.deltaPerMinute !== 0)
+            problems.push(`change rule on ${on}: with onEvent, deltaPerMinute must be 0`);
+        if (onType !== undefined && !valueMatchesType(onType, mechanic.onEvent.value))
+            problems.push(`change rule on ${on}: onEvent.value must be a ${onType} value`);
+        const subject = mechanic.onEvent.subjectPropertyId;
+        if (typeOf(subject) !== 'id')
+            problems.push(`change rule on ${on}: onEvent.subjectPropertyId ${subject} is ${typeOf(subject) === undefined ? 'not a property' : `a ${typeOf(subject)} property`}; it must name an id property`);
+    }
+    if (mechanic.kind === 'gate') {
+        const subject = mechanic.subjectPropertyId;
+        if (typeOf(subject) !== 'id')
+            problems.push(`gate rule on ${on}: subjectPropertyId ${subject} is ${typeOf(subject) === undefined ? 'not a property' : `a ${typeOf(subject)} property`}; it must name an id property`);
+        if (mechanic.atLeast !== undefined && onType !== undefined && onType !== 'level')
+            problems.push(`gate rule on ${on}: atLeast needs a level property, not ${onType}`);
+    }
+    return problems;
+}
+// What is wrong with a proposed kind, each problem naming the slot or rule at fault.
+function definitionProblems(answer, request, existing) {
+    const parsed = kindDefinitionSchema.safeParse(answer);
+    if (!parsed.success)
+        return [`The kind does not fit its shape: ${parsed.error.message}`];
+    const definition = parsed.data;
+    const problems = [];
+    const problem = (message) => { if (!problems.includes(message))
+        problems.push(message); };
+    if (definition.id !== request.id)
+        problem(`The requested kind id must stay ${request.id}`);
+    if (existing.some(kind => kind.id === definition.id))
+        problem('The requested kind already exists');
+    const propertyIds = definition.properties.map(property => property.id);
+    for (const [index, id] of propertyIds.entries())
+        if (propertyIds.indexOf(id) !== index)
+            problem(`Property ${id} appears twice`);
+    const relationIds = definition.relations.map(relation => relation.id);
+    for (const [index, id] of relationIds.entries())
+        if (relationIds.indexOf(id) !== index)
+            problem(`Relation ${id} appears twice`);
+    if (new Set(definition.mechanics.map(mechanic => JSON.stringify(mechanic))).size !== definition.mechanics.length)
+        problem('A kind repeats a mechanic');
+    for (const relation of definition.relations) {
+        if (propertyIds.includes(relation.id))
+            problem(`Slot ${relation.id} is both a property and a relation; give the relation another id or drop it`);
+        if (relation.targetKindId !== definition.id && !existing.some(kind => kind.id === relation.targetKindId)) {
+            problem(`Relation ${relation.id} points to unknown kind ${relation.targetKindId}; use this kind or a listed one`);
+        }
+    }
+    for (const mechanic of definition.mechanics)
+        for (const message of ruleProblems(mechanic, definition))
+            problem(message);
+    return problems;
+}
+// The part of a proposed kind that holds: every slot that is sound and every rule that fits its
+// slots. A kind whose id is wrong keeps nothing.
+function soundPart(answer, request, existing) {
+    const parsed = kindDefinitionSchema.safeParse(answer);
+    if (!parsed.success || parsed.data.id !== request.id || existing.some(kind => kind.id === request.id))
+        return null;
+    const definition = parsed.data;
+    const properties = definition.properties.filter((property, index, all) => all.findIndex(other => other.id === property.id) === index);
+    const relations = definition.relations.filter((relation, index, all) => all.findIndex(other => other.id === relation.id) === index
+        && !properties.some(property => property.id === relation.id)
+        && (relation.targetKindId === definition.id || existing.some(kind => kind.id === relation.targetKindId)));
+    const slots = { ...definition, properties, relations };
+    const mechanics = definition.mechanics.filter((mechanic, index, all) => all.findIndex(other => JSON.stringify(other) === JSON.stringify(mechanic)) === index
+        && ruleProblems(mechanic, slots).length === 0);
+    const kept = { ...slots, mechanics };
+    return definitionProblems(kept, request, existing).length === 0 ? kept : null;
+}

package/dist/simulation/living/definition.d.ts

@@ -0,0 +1,257 @@
+import { z } from 'zod';
+import { type LivingState } from './types.js';
+export declare const definitionSchema: z.ZodObject<{
+    kind: z.ZodString;
+    title: z.ZodString;
+    tagline: z.ZodString;
+    setting: z.ZodString;
+    startClock: z.ZodNumber;
+    clock: z.ZodOptional<z.ZodObject<{
+        rate: z.ZodNumber;
+    }, z.core.$strip>>;
+    messages: z.ZodOptional<z.ZodObject<{
+        minutes: z.ZodNumber;
+        how: z.ZodString;
+    }, z.core.$strip>>;
+    currency: z.ZodNullable<z.ZodObject<{
+        symbol: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>>;
+    accounts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        holderId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        balance: z.ZodNumber;
+        allowsDebt: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    places: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        kind: z.ZodEnum<{
+            private: "private";
+            transit: "transit";
+            room: "room";
+            outdoors: "outdoors";
+        }>;
+        summary: z.ZodString;
+        connections: z.ZodArray<z.ZodString>;
+        conditions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    player: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        role: z.ZodString;
+        roleId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        summary: z.ZodString;
+        pronouns: z.ZodOptional<z.ZodString>;
+        placeId: z.ZodString;
+        money: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+    cast: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        role: z.ZodString;
+        roleId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        summary: z.ZodString;
+        persona: z.ZodOptional<z.ZodString>;
+        character: z.ZodOptional<z.ZodObject<{
+            voice: z.ZodString;
+            values: z.ZodArray<z.ZodString>;
+            redLines: z.ZodArray<z.ZodString>;
+            privateConcerns: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        pronouns: z.ZodOptional<z.ZodString>;
+        placeId: z.ZodString;
+        money: z.ZodNullable<z.ZodNumber>;
+        mood: z.ZodString;
+        goals: z.ZodArray<z.ZodString>;
+        beliefs: z.ZodArray<z.ZodObject<{
+            subject: z.ZodString;
+            claim: z.ZodString;
+        }, z.core.$strip>>;
+        relationships: z.ZodRecord<z.ZodString, z.ZodObject<{
+            trust: z.ZodNumber;
+            warmth: z.ZodNumber;
+            note: z.ZodString;
+        }, z.core.$strip>>;
+        plan: z.ZodNullable<z.ZodObject<{
+            intent: z.ZodString;
+            seen: z.ZodOptional<z.ZodString>;
+            placeId: z.ZodNullable<z.ZodString>;
+            targetId: z.ZodNullable<z.ZodString>;
+            inMinutes: z.ZodNumber;
+        }, z.core.$strip>>;
+        knownAtStart: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    objects: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        summary: z.ZodString;
+        placeId: z.ZodNullable<z.ZodString>;
+        holderId: z.ZodNullable<z.ZodString>;
+        ownerId: z.ZodNullable<z.ZodString>;
+        condition: z.ZodString;
+        singlePersonMovable: z.ZodDefault<z.ZodBoolean>;
+        knownTo: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        hidden: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    kinds: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        meaning: z.ZodString;
+        properties: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodEnum<{
+                number: "number";
+                id: "id";
+                flag: "flag";
+                text: "text";
+                level: "level";
+                time: "time";
+            }>;
+            requiredOnCreate: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        relations: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            targetKindId: z.ZodString;
+        }, z.core.$strip>>;
+        mechanics: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"spread">;
+            propertyId: z.ZodString;
+            relationId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"signal">;
+            propertyId: z.ZodString;
+            relationId: z.ZodString;
+            channel: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"change">;
+            propertyId: z.ZodString;
+            deltaPerMinute: z.ZodNumber;
+            onEvent: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodLiteral<"move">;
+                subjectPropertyId: z.ZodString;
+                value: z.ZodUnion<readonly [z.ZodBoolean, z.ZodNumber, z.ZodEnum<{
+                    none: "none";
+                    low: "low";
+                    medium: "medium";
+                    high: "high";
+                }>, z.ZodString]>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"trigger">;
+            propertyId: z.ZodString;
+            threshold: z.ZodNumber;
+            direction: z.ZodEnum<{
+                "at-least": "at-least";
+                "at-most": "at-most";
+            }>;
+            intent: z.ZodString;
+            delayMinutes: z.ZodNumber;
+            minImportance: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"gate">;
+            propertyId: z.ZodString;
+            subjectPropertyId: z.ZodString;
+            atLeast: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                low: "low";
+                medium: "medium";
+                high: "high";
+            }>>;
+            blockedActionKinds: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"norm">;
+            actionKind: z.ZodString;
+            roleId: z.ZodNullable<z.ZodString>;
+            forbidden: z.ZodBoolean;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"authority">;
+            roleId: z.ZodString;
+            relationId: z.ZodNullable<z.ZodString>;
+            propertyId: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>], "kind">>;
+    }, z.core.$strip>>>;
+    entities: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kindId: z.ZodString;
+        name: z.ZodString;
+        placeId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        properties: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodBoolean, z.ZodNumber, z.ZodEnum<{
+            none: "none";
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>, z.ZodString]>>>;
+        relations: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+        members: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        settles: z.ZodOptional<z.ZodString>;
+        knownTo: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        hidden: z.ZodOptional<z.ZodBoolean>;
+        transfers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            fromId: z.ZodNullable<z.ZodString>;
+            toId: z.ZodNullable<z.ZodString>;
+            amount: z.ZodNumber;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    facts: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        aspect: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strip>]>>;
+    opening: z.ZodObject<{
+        title: z.ZodString;
+        situation: z.ZodString;
+        stakes: z.ZodString;
+    }, z.core.$strip>;
+    tension: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        summary: z.ZodString;
+        participantIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    playerRelationships: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        trust: z.ZodNumber;
+        warmth: z.ZodNumber;
+        note: z.ZodString;
+    }, z.core.$strip>>>;
+    beats: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        unless: z.ZodOptional<z.ZodObject<{
+            settled: z.ZodString;
+        }, z.core.$strip>>;
+        then: z.ZodOptional<z.ZodObject<{
+            facts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                aspect: z.ZodString;
+                text: z.ZodString;
+            }, z.core.$strip>>>;
+            tension: z.ZodOptional<z.ZodObject<{
+                id: z.ZodString;
+                summary: z.ZodOptional<z.ZodString>;
+                status: z.ZodOptional<z.ZodEnum<{
+                    settled: "settled";
+                    open: "open";
+                }>>;
+            }, z.core.$strip>>;
+            transfers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                fromId: z.ZodNullable<z.ZodString>;
+                toId: z.ZodNullable<z.ZodString>;
+                amount: z.ZodNumber;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        reach: z.ZodOptional<z.ZodEnum<{
+            nearby: "nearby";
+            everywhere: "everywhere";
+        }>>;
+        heard: z.ZodOptional<z.ZodString>;
+        deadline: z.ZodOptional<z.ZodBoolean>;
+        id: z.ZodString;
+        inMinutes: z.ZodNumber;
+        placeId: z.ZodString;
+        text: z.ZodString;
+        everyMinutes: z.ZodOptional<z.ZodNumber>;
+        concerns: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type LivingWorldDefinition = z.infer<typeof definitionSchema>;
+export type LivingWorldDefinitionInput = z.input<typeof definitionSchema>;
+export declare function parseLivingWorldDefinition(value: unknown): LivingWorldDefinition;
+export declare function createLivingState(definition: LivingWorldDefinition, seed: string, engine?: number): LivingState;