@khorsheed/dsh-game 0.0.0-stage → 0.1.1

package/lib/types/panel-session.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The session a panel call names, by id. The wire's `agent`/`session` lookups
+ * refuse identities owned by subagent routing (a room's CLI member, a native
+ * subagent), so a panel opened on such a session could not even read. Panel
+ * calls take the session id instead: an attached session — subagent ones
+ * included — answers directly; anything else goes through the host's own
+ * `session` lookup, which resumes an ordinary cold session and raises the
+ * same errors a lookup parameter did.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Session } from '@deepseek-ai/dsh-session';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+/**
+ * Resolve the session a panel call names.
+ * @param ctx - host context carrying the session store and the typert lookups.
+ * @param sessionId - the session the panel shows.
+ * @returns the session.
+ * @throws the host lookup's refusal, or when no session has that id.
+ */
+export declare function panelSession(ctx: Context, sessionId: SessionId): Promise<Session>;
+//# sourceMappingURL=panel-session.d.ts.map

package/lib/types/panel-session.js

@@ -0,0 +1,16 @@
+/**
+ * Resolve the session a panel call names.
+ * @param ctx - host context carrying the session store and the typert lookups.
+ * @param sessionId - the session the panel shows.
+ * @returns the session.
+ * @throws the host lookup's refusal, or when no session has that id.
+ */
+export async function panelSession(ctx, sessionId) {
+    const attached = ctx.get('sessions')?.get(sessionId);
+    if (attached !== undefined)
+        return attached;
+    const resolved = await ctx.get('typert')?.lookups.get('session')?.resolve(sessionId);
+    if (resolved === undefined)
+        throw new Error(`session "${sessionId}" not found`);
+    return resolved;
+}

package/lib/types/project.d.ts

@@ -0,0 +1,138 @@
+import type { KitId, RuntimeKit } from './kits/types.ts';
+import { type ArtStyle, type ChapterStatus, type CheckFailure, type ElementLook, type ElementView, type GameManifest, type GameParam } from './types.ts';
+/** What `game_open create` must carry before a project exists (the light gate, decision D2). */
+export interface CreateRequest {
+    /** `2d` (default) or `3d`; the kit the project is pinned to. */
+    readonly runtime?: string | undefined;
+    readonly title?: string | undefined;
+    readonly pitch?: string | undefined;
+    readonly elementTypes?: readonly string[] | string | undefined;
+    readonly artStyle?: string | undefined;
+    readonly pillars?: readonly string[] | string | undefined;
+}
+/** The gate's verdict: a manifest to write, or what is still missing (model-facing Chinese). */
+export type GateVerdict = {
+    readonly ok: true;
+    readonly manifest: Omit<GameManifest, 'id' | 'createdAt'>;
+} | {
+    readonly ok: false;
+    readonly missing: readonly string[];
+};
+/** Split a list given either as an array or as one 、/,/newline-separated string. */
+export declare function listOf(value: readonly string[] | string | undefined): string[];
+/**
+ * Resolve the art style the user picked: an example id, its Chinese label,
+ * or `custom:<description>`. Anything else is not a choice the user made.
+ * @param value - what the model passed.
+ * @returns the stored spelling, or undefined when it names no style.
+ */
+export declare function resolveArtStyle(value: string | undefined, styles?: readonly ArtStyle[]): string | undefined;
+/** The style's human label (`custom:` keeps the user's own words). */
+export declare function artStyleLabel(id: string): string;
+/**
+ * A style's short name for tight places (tags, chips): a custom description's
+ * lead — up to its first dash, colon, comma or bracket — at most 10 characters.
+ * The full label stays for the model and for hover text.
+ */
+export declare function artStyleName(id: string): string;
+/** The kit a create request asks for: `3d` / `3d-three` → 3D, anything else 2D. */
+export declare function requestedKit(runtime: string | undefined): KitId;
+/** The example styles a kit offers. */
+export declare function stylesFor(kit: KitId): readonly ArtStyle[];
+/**
+ * The light gate: a project needs a title, a one-sentence pitch, at least one
+ * element type and a chosen art style. The model gets back exactly what is
+ * missing, so it asks the user instead of inventing it.
+ * @param request - the create arguments.
+ * @returns the manifest body, or the missing items.
+ */
+export declare function gate(request: CreateRequest): GateVerdict;
+/** A style's palette; custom styles start from the pixel palette (the agent may set its own in game.json). */
+export declare function stylePalette(styleId: string): string[];
+/** Parse `game.json` `params[]`, dropping malformed rows and clamping each value into its range. */
+export declare function parseParams(raw: unknown): GameParam[];
+/** What a usable pixel look needs, worded for the model. */
+export declare const PIXEL_LOOK_HINT = "look \u4E0D\u53EF\u7528\uFF1A\u9700\u8981 palette\uFF08#rrggbb \u6570\u7EC4\uFF09\u548C states\uFF08\u72B6\u6001\u540D \u2192 \u50CF\u7D20\u884C\u6570\u7EC4\uFF09";
+/**
+ * Normalize an element's `look`: a palette of `#rrggbb` colors and pixel
+ * rows per state, every row padded/cut to the widest row, characters outside
+ * the palette turned transparent. Anything unusable is null.
+ */
+export declare function normalizeLook(raw: unknown): ElementLook | null;
+/** The look's grid size (first state). */
+export declare function lookSize(look: ElementLook): {
+    w: number;
+    h: number;
+};
+/**
+ * Parse `game.json`. Unknown keys are dropped; a missing optional key takes
+ * its default, so a hand-edited manifest still loads.
+ * @param text - the file's contents.
+ * @returns the manifest, or a Chinese reason.
+ */
+export declare function parseManifest(text: string): {
+    ok: true;
+    manifest: GameManifest;
+} | {
+    ok: false;
+    error: string;
+};
+/** Serialize a manifest the way the plugin writes it. */
+export declare function serializeManifest(manifest: GameManifest): string;
+/**
+ * A chapter's status from its text: empty is `todo`, a `状态：定稿` (or
+ * `status: done`) line is `done`, anything else is a `draft`.
+ */
+export declare function chapterStatus(text: string | undefined): ChapterStatus;
+/**
+ * The one-pager (pitch, element types, style, pillars) lives in `game.json`
+ * and the panel pins it; `design/pillars.md` holds only the notes about the
+ * pillars (why each matters, how to test it). Projects created before
+ * 2026-10-10 got a pillars.md that restated the one-pager: this strips those
+ * restated lines so the notes view never shows the card twice.
+ * @param text - the chapter's text.
+ * @param manifest - the one-pager it may restate.
+ * @returns the notes that are not a restatement (trimmed; '' when none).
+ */
+export declare function pillarNotes(text: string, manifest: Pick<GameManifest, 'title' | 'pitch' | 'pillars' | 'artStyle' | 'elementTypes'> | null): string;
+/**
+ * Validate the element files. A file holds one element object or an array of
+ * them; each needs `id`, `name` and a `type` the manifest declares, and ids
+ * are unique across files.
+ * @param files - project-relative path → contents, only `elements/*.json`.
+ * @param elementTypes - the manifest's declared types (empty = accept any).
+ * @param looks - how the project's kit normalizes a `look` (default: 2D pixel rows).
+ * @returns the elements that parsed, and one failure per problem.
+ */
+export declare function validateElements(files: Readonly<Record<string, string>>, elementTypes: readonly string[], looks?: Pick<RuntimeKit, 'normalizeLook' | 'lookHint'>): {
+    elements: ElementView[];
+    failures: CheckFailure[];
+};
+/** The generated 元素与数值 chapter: one table per element type. */
+export declare function elementsChapter(elements: readonly ElementView[], elementTypes: readonly string[]): string;
+/** The generated 元素设定 chapter: every element's 设定 by type (elements without one are left out). */
+export declare function loreChapter(elements: readonly ElementView[], elementTypes: readonly string[]): string;
+/**
+ * Whether a project-relative path belongs in a playable build: everything
+ * except the plugin's state, the design doc, the tests and dot-files.
+ */
+export declare function isBuildFile(path: string): boolean;
+/** A file's MIME type by extension. */
+export declare function mimeOf(path: string): string;
+/** Whether a file ships to the sandbox as text. */
+export declare function isTextFile(path: string): boolean;
+/**
+ * A directory-safe project folder name from a title: ASCII letters and
+ * digits kept, other runs collapsed to `-`; a title with none falls back to
+ * `game`. The store appends `-2`, `-3` … on collision.
+ */
+export declare function slugOf(title: string): string;
+/**
+ * Apply a patch to one element inside its file's text (an object, or one
+ * entry of an array), keeping every other key. `undefined` values delete.
+ * @returns the new file text, or undefined when the element is not there.
+ */
+export declare function patchElementText(text: string, elementId: string, patch: Readonly<Record<string, unknown>>): string | undefined;
+/** A look as model-facing text: palette, then each state's rows. */
+export declare function lookText(look: ElementLook): string;
+//# sourceMappingURL=project.d.ts.map