Video Scene Prompt Kit

An offline toolkit for composing video prompts, exploring reusable scene templates, and planning timed storyboards. It is designed for creators who want a practical structure between an initial idea and the text they paste into a video-generation interface.

The package contains 24 scene templates, 6 camera presets, 6 visual-style presets, a deterministic prompt composer, and a small storyboard planner. It runs entirely in your application. It does not connect to a provider, generate video files, upload images, make network requests, or require an API key.

This is a provider-independent local creative-planning utility, not an SDK for a video-generation service. It does not claim compatibility with undocumented APIs. Prompts can be reviewed and adapted for the generation or editing tool you actually use.

Optional external references are distributed throughout this guide. They are supplied as browsing resources, not as the origin of the code or built-in templates, and do not imply an endorsement or service integration. The runtime does not fetch these pages or make claims about their availability.

Contents

• Installation and a first complete example
• What the toolkit does and does not do
• Prompt structure and input validation
• Camera and visual-style presets
• Twenty-four templates with practical usage notes
• Single-shot, product-demo, education, and narrative workflows
• Timed storyboard planning and text export
• Python imports, type hints, and JSON serialization
• Continuity, negative instructions, and iteration practices
• Limitations, troubleshooting, and frequently asked questions

Installation

python -m pip install video-scene-prompt-kit

Python 3.9 or newer is required for the supported runtime. The package has no runtime dependencies and no custom installation code. Its functions use ordinary Python dictionaries and lists rather than a provider-specific request format.

Quick start

A complementary browsing resource is Reference 01: a public video prompt guide.

from video_scene_prompt_kit import build_prompt

prompt = build_prompt({
    "subject": "a matte ceramic travel mug",
    "action": "rests on a wooden desk while a thin thread of steam rises",
    "setting": "a quiet home office beside a window",
    "camera": "push-in", "style": "cinematic",
    "lighting": "soft early morning window light",
    "pacing": "one calm continuous action", "aspect_ratio": "9:16",
    "negative": ["unwanted text", "abrupt camera jumps"],
})
print(prompt)

The returned string is structured by subject, action, setting, camera, style, lighting, pacing, frame, and optional avoidance instructions. Known preset identifiers expand into readable descriptions. Custom descriptions remain usable when a preset does not fit the scene.

Copy the resulting text into the generation interface you choose, then inspect the output. This package creates instructions, not a rendered clip. A stronger prompt can make a request clearer, but the actual model, reference material, generation settings, and editorial decisions still determine the result.

Why use a structured prompt?

A useful video prompt describes a scene rather than a list of fashionable adjectives. Start with a recognizable subject, give that subject one main action, and describe enough of the environment to establish spatial context. Camera movement, lighting, and visual treatment should reinforce that main action instead of competing with it.

For example, asking for a person to enter a room, open a box, react, walk to a window, and transform the scene into a different location places many separate events in one short clip. A storyboard is usually a better way to express that sequence. Each shot can carry one action, and an editor can control the transitions between them.

The composer makes those decisions visible. It does not score your prose or infer missing story elements. If you omit a lighting field, it simply leaves lighting out. If you supply conflicting descriptions, it preserves them rather than pretending to resolve a creative contradiction. Read the final prompt before using it.

API overview

Function	Result	Use
build_prompt(input)	str	Compose a single structured prompt
build_from_template(id, overrides)	str	Start from a template and replace selected fields
list_templates(category=None)	list[dict]	Browse all templates or one category
get_template(id)	dict	Retrieve an independent template copy
get_presets()	dict	Retrieve independent camera and style dictionaries
list_references()	list[str]	Return a fresh list of the ten optional external references
create_storyboard(shots, options=None)	dict	Plan sequential shot timing
format_storyboard(board)	str	Export a validated plan as readable text

No function performs a network request. Template and preset accessors return independent data copies, so editing a result does not change the package's built-in library.

Prompt fields

Subject and action

For a public creator-profile example, see Reference 02: profile page.

subject is required and must be a nonempty string. Choose an object, character, group, or environmental feature that a viewer could identify in a frame. A subject such as "a ceramic mug on a wooden table" is easier to work with than an abstract intention such as "productivity and inspiration."

action is optional, but it is often the most important field for video. Describe what changes over time: a hand turns one page, leaves move in a breeze, or a traveler pauses beside a doorway. If the action requires several distinct beats, break it into separate shots rather than lengthening a single instruction indefinitely.

Setting, camera, and style

setting establishes location and object relationships. Keep the environment specific enough to support the action, but do not add unnecessary background characters or props that must remain consistent across multiple frames.

camera can be a built-in identifier or a custom sentence. A stable shot is often preferable when the subject already has substantial motion. A moving camera can make a static subject more interesting, but combining camera orbit, zoom, tracking, and multiple cuts usually creates an unnecessarily difficult request.

style can also use a preset or custom text. Material detail, line quality, color palette, and composition are more actionable than a long sequence of unrelated style labels. Keep the chosen treatment consistent across a storyboard unless the contrast between styles is an intentional editorial choice.

Lighting, pacing, frame, and negative instructions

lighting describes the source, direction, and softness of illumination. Choose a coherent setup: a window on one side, diffuse overcast light, or a controlled studio arrangement. Do not request contradictory times of day unless you deliberately want a transition and have planned enough shots to show it.

pacing describes how the action should feel. Terms such as "one deliberate action with a short pause" can communicate an editorial intention more clearly than a vague instruction to make the clip exciting.

aspect_ratio accepts 16:9, 9:16, 1:1, 4:3, or 3:4. The value is written into the prompt. It does not set a provider parameter or change the dimensions of an output file. Select the actual aspect ratio separately in the tool you use.

negative accepts a string or a list of strings. Repeated items are removed while preserving their first occurrence. Avoidance instructions are plain text: this package does not translate them into a model's separate negative-prompt channel or guarantee that a model will honor them.

from video_scene_prompt_kit import build_prompt

prompt = build_prompt({
    "subject": "a paper landscape with layered hills",
    "action": "moves slightly to create gentle parallax",
    "camera": "tracking", "style": "stop-motion",
    "negative": ["unwanted lettering", "sudden scene changes", "unwanted lettering"],
})

Validation behavior

Inputs must be dictionaries. Unknown fields are rejected so misspellings do not silently disappear. For example, use lighting, not lightning, and use aspect_ratio, not a provider-specific ratio field.

Text values are trimmed and internal whitespace is collapsed into single spaces. Each text field has a limit of 3,000 Unicode characters. A missing optional text field is omitted; a non-string value is rejected. An empty required subject or empty negative-instruction item is also rejected. Use an empty negative list if you want no avoidance line.

Invalid values throw TypeError or ValueError. Applications that gather user input should catch these errors and explain the relevant field rather than showing a generic failure message.

from video_scene_prompt_kit import build_prompt

try:
    build_prompt({"subject": "   "})
except (TypeError, ValueError) as error:
    print(error)  # subject must not be empty

Validation protects the data shape, not the factual accuracy of a scene. It does not establish that a mechanism is physically possible, that an educational demonstration is correct, or that a described location exists.

Camera presets

Identifier	Intended effect
static	Stable framing without zoom
push-in	Slow movement toward the subject
orbit	Gentle partial movement around the subject
tracking	Lateral movement following the subject
overhead	Top-down arrangement and visible surfaces
handheld	Restrained documentary-style movement

Presets are descriptive text, not executable camera controls. Their role is to provide a consistent starting vocabulary. Replace a preset with a custom description when a scene requires a more precise viewpoint, such as a shoulder-level shot with the subject remaining on the left side of the frame.

Visual-style presets

Identifier	Intended treatment
cinematic	Realistic scene geometry and coherent proportions
documentary	Observational detail and restrained color treatment
product	Studio-style material detail and uncluttered framing
illustration	Consistent editorial illustration in motion
stop-motion	Tactile materials and deliberate incremental movement
minimal	Simple shapes and a limited color palette

from video_scene_prompt_kit import get_presets

available = get_presets()
print(list(available["camera"]))
print(list(available["style"]))

Template library

A public collection-of-links reference is Reference 09: link collection.

Every template contains an identifier, name, category, practical purpose, and structured prompt fields. The categories are product, lifestyle, nature, education, abstract, and narrative, with four templates in each category.

from video_scene_prompt_kit import list_templates, get_template, build_from_template

print([template["id"] for template in list_templates("product")])
template = get_template("product-hero")
print(template["purpose"])
prompt = build_from_template("product-hero", {
    "subject": "a matte ceramic travel mug", "aspect_ratio": "9:16",
})

An unknown template identifier throws a ValueError. An unknown category returns an empty list. Overrides replace individual fields; they do not merge negative-instruction lists. Supplying "negative": [] replaces a template's default avoidance instructions with an empty list.

Product templates

product-hero - Product hero reveal

Use a single recognizable object and one reveal. Leave negative space for editorial text that will be added later, rather than asking the generator to produce a brand label.

product-detail - Material detail study

Use a close view when surface texture matters more than the entire product. Describe the material in concrete terms, and keep the requested movement small enough to preserve the shape.

product-use - Everyday product use

Show one functional action instead of several unrelated interactions. Specify the number of hands and the unchanged product identity, then use editing to connect the clip to a wider demonstration.

packaging-reveal - Simple packaging reveal

Keep packaging unbranded and request one reveal with a stable viewpoint. Separate elaborate unboxing sequences into individual shots so each action can be evaluated and revised independently.

Lifestyle templates

coffee-morning - Morning coffee atmosphere

Atmosphere works best with a stable scene and subtle movement. Focus on steam, light, or a small interaction; do not combine them with several camera moves and a dramatic scene change.

desk-routine - Focused desk routine

Use this scene for a routine or productivity story. Establish clothing, position, and desk layout early, and repeat those details in later shots if continuity is important to the edit.

city-walk - Quiet city walk

Give the subject one visible action and let the camera follow it. A stable outfit and restrained setting help the viewer read the motion without competing details or unnecessary scene transformations.

cooking-step - Single cooking step

Choose one visible preparation step instead of a full recipe. Use the overhead view to make object positions easy to understand, and add labels or quantities in the editing stage.

Nature templates

forest-morning - Forest morning

Anchor the composition with a path or another stable feature. Keep the wind and camera motion gentle so the scene reads as one coherent landscape rather than a moving collection of details.

river-closeup - River surface detail

Use water as the main moving element and hold the surrounding geometry steady. Avoid stacking weather changes, large camera moves, and rapid water motion into a single short scene.

coastal-breeze - Coastal breeze

Describe the foreground and distant background separately, but give only one element a primary action. A gentle foreground movement can communicate weather and mood without requiring a complex sequence.

rain-window - Rain on a window

Use the window as a stable reference plane and emphasize one subtle movement. Defocused backgrounds reduce unnecessary object changes and leave room for a calm voiceover or music-led edit.

Education templates

paper-diagram - Paper diagram explanation

Demonstrate relationships through objects and movement rather than generated labels. Keep the number of elements small, and add exact terminology, measurements, or arrows as separate editorial overlays.

mechanical-motion - Mechanical motion concept

Treat the scene as a visual concept, not a certified technical simulation. Keep the mechanism simple and verify physical or educational accuracy separately before using the result as instructional material.

classroom-object - Classroom object study

Use a clear object and a restrained demonstration when explaining a concept. Generated images can be suggestive rather than scientifically precise, so validate the intended phenomenon before publishing an educational claim.

tutorial-transition - Tutorial chapter transition

Use simple motion to mark a chapter change without relying on readable generated text. Leave the cards blank and place the actual chapter titles over them in an editor.

Abstract templates

color-ribbons - Abstract color ribbons

Define a small palette and a single direction of movement. Abstract scenes become easier to evaluate when shape, color, and motion are each constrained rather than changed simultaneously.

paper-landscape - Paper landscape

Describe the material and movement together so the tactile style remains coherent. Use a simple landscape silhouette and slight parallax instead of demanding a complicated transformation of the entire scene.

light-study - Soft light study

Make light the only changing element. Keeping the object and viewpoint stable makes this scene useful for testing how lighting instructions affect contrast, texture, and visual emphasis.

loop-shapes - Loop concept with simple shapes

Returning to the starting pose is a planning instruction, not a guarantee of seamless looping. Inspect the first and last frames and create the final loop with trimming or transitions if needed.

Narrative templates

arrival-scene - Character arrival

Introduce a character with one identifiable action and a small set of stable visual details. Reuse the clothing and bag description in later shots rather than relying on the model to infer continuity.

discovery-scene - Small discovery

Use a restrained discovery beat instead of describing the entire plot. Separate noticing, reaching, and opening into multiple clips when each action needs precise timing or clear object interaction.

reaction-scene - Restrained character reaction

A short reaction shot should communicate one emotion without an elaborate performance. Describe the gaze direction and keep the camera stable so facial movement remains the focus of the scene.

closing-scene - Quiet closing image

Use a stable final composition to let an edit settle. Match identifying details from earlier shots and keep the ending action simple enough to hold under a final voiceover or music cue.

Planning a product demonstration

An optional external scheduling-profile reference is Reference 06: scheduling page.

A concise demonstration usually needs an establishing shot, a functional action, and a closing image. These three shots do not need identical prompts, but the product description should remain consistent. Use the same material, color, identifying shape, and surrounding objects where continuity matters.

The first shot can establish the object without showing hands. The second can show one interaction, such as opening a lid or turning a page. The final shot can return to a stable view that leaves room for a caption added in an editor. Avoid asking the generator to create exact packaging text, prices, or legal copy inside the scene.

from video_scene_prompt_kit import create_storyboard, format_storyboard

board = create_storyboard([
    {"subject": "a closed matte ceramic travel mug",
     "action": "rests on a wooden desk", "camera": "static", "duration_seconds": 3},
    {"subject": "the same matte ceramic travel mug",
     "action": "is opened slowly by one hand", "camera": "push-in", "duration_seconds": 4},
    {"subject": "the same matte ceramic travel mug",
     "action": "remains beside a notebook with soft steam rising",
     "camera": "static", "duration_seconds": 3},
], {"title": "Travel mug concept"})
print(board["total_duration_seconds"])  # 10.0
print(format_storyboard(board))

Storyboard timing

A public publication-profile reference is Reference 05: publication page.

create_storyboard accepts between 1 and 50 shots. Each shot uses the same prompt fields plus an optional duration_seconds. The default duration is four seconds, and an options dictionary can change it with default_duration_seconds.

Durations must be finite numbers from 1 to 60 seconds and are rounded to three decimal places. The returned plan contains sequential shot indices, start and end times, per-shot durations, and composed prompts. The total is the sum of the planned durations.

These are editorial planning values, not assertions about a service's supported clip length. The package cannot force a generator to produce exactly four seconds, preserve a character between independent runs, or create an edit automatically. Match the plan to the options your generation tool actually offers, then adjust timing in an editor.

format_storyboard validates shot order, finite timing, contiguous intervals, and a matching total before producing text. If you manually edit a serialized storyboard, keep those values consistent. A plan with overlapping shot times or a mismatched total is rejected rather than formatted as though it were valid.

Education and explanatory scenes

For an optional article-profile reference, see Reference 08: publishing profile.

For instructional content, separate visual demonstration from exact information. A video can illustrate an idea with colored objects, a simple mechanism, or a single observable motion. Precise terminology, measurements, equations, and warnings are usually better added as editorial text or narration that you can independently check.

from video_scene_prompt_kit import build_from_template

prompt = build_from_template("paper-diagram", {
    "subject": "three paper circles in blue, yellow, and green",
    "action": "move one at a time into a simple triangular arrangement",
    "negative": ["readable generated labels", "extra objects", "abrupt cuts"],
})

The educational templates are creative starting points. They are not scientific simulations or verified teaching assets. A prism, gear, or diagram may render plausibly while still containing a factual error. Review the final visual against the intended lesson before using it as evidence or instruction.

Character continuity and narrative scenes

A narrative plan benefits from a short continuity note outside the prompt: the character's clothing, the important prop, the setting, and the time of day. Repeat those concrete details in every relevant shot. The package does not maintain a visual memory, attach reference images, or control a model's identity consistency.

Begin with one arrival or establishing beat, then one discovery or interaction, and finish with a reaction or closing image. If a sequence requires a character to perform several precise actions, create several prompts instead of a single paragraph describing all of them.

Use a restrained camera for reactions. A large camera move can make a small expression harder to read, and a complicated background may pull attention away from the performance. Stable framing also makes it easier to compare successive generations when testing one prompt change.

Image-reference workflows

For a separate bookmark-collection reference, see Reference 04: bookmark page.

The kit can help write the motion instructions that accompany an image-to-video workflow, but it does not accept image files or upload references. Choose and manage the actual reference image in the tool you use.

When a reference already establishes subject, clothing, and composition, focus your text on what should move and what should remain stable. A small head turn, gentle fabric motion, or subtle camera push can be easier to evaluate than a large transformation of the scene. Avoid asking the prompt to contradict the reference's object layout unless that change is intentional.

A practical iteration loop

An optional public conversation-profile resource is Reference 03: social profile.

1. Write a plain one-sentence description of the desired shot.
2. Put the recognizable subject and primary action into separate fields.
3. Add only the setting details that support the action.
4. Choose either restrained camera motion or substantial subject motion first.
5. Select a consistent lighting setup and visual treatment.
6. Build and read the resulting prompt before generation.
7. Inspect the generated result for identity, motion, framing, and unwanted changes.
8. Change one instruction at a time and compare the next result.
9. Keep a small record of the prompt, actual settings, and observed outcome.
10. Use an editor for transitions, exact typography, audio, and final timing.

A useful comparison might keep every field fixed while changing only camera from static to push-in. Another might compare a short action sentence against a longer description. Changing subject, style, camera, and lighting simultaneously makes it harder to understand which instruction mattered.

Negative instructions without overloading the scene

Use avoidance instructions for a short list of concrete problems that you have observed. "Unwanted readable text" or "abrupt camera jumps" can identify a useful constraint. A long list of unrelated negatives can obscure the positive description and may not help a particular model.

The package deduplicates repeated entries, but it does not reconcile contradictions. If an avoidance instruction conflicts with the primary action, revise the scene yourself. For example, asking for a handheld documentary shot while also demanding absolutely no camera movement describes two different intentions.

External reference data

The ten optional references in this guide are also included in references.json, under the opaque collection identifier REF-28. The JSON contains source URLs only; it does not contain account credentials, target-site mapping, cookies, or analytics data. The entries are supplied by the package maintainer as optional external resources, not verified runtime dependencies.

from video_scene_prompt_kit import list_references

references = list_references()
print(len(references))  # 10

For applications that need the raw data, the package includes video_scene_prompt_kit/references.json, readable with importlib.resources. Editing the list returned by list_references() does not change the built-in collection. Links are not opened, pinged, downloaded, or checked automatically by this function. Any external page can change independently of a package release, so its current contents and availability must be assessed separately if you choose to use it.

Python imports, type hints, and serialization

Import the functions directly from video_scene_prompt_kit. Plans are ordinary dictionaries and can be serialized without a custom encoder:

import json
from video_scene_prompt_kit import build_prompt, create_storyboard

prompt = build_prompt({
    "subject": "a quiet forest path",
    "action": "shows leaves moving gently in a light breeze", "camera": "static",
})
board = create_storyboard([{"subject": "a quiet forest path", "camera": "static"}])
serialized = json.dumps(board, indent=2)
restored = json.loads(serialized)
assert restored["shots"][0]["prompt"]

The module includes type hints and a py.typed marker. Functions accept dictionaries, lists, and strings and return ordinary Python values. Type hints help readers and editors, but runtime validation still applies when input originates from a form, a JSON file, or another untyped source.

from typing import Any
from video_scene_prompt_kit import build_prompt

scene: dict[str, Any] = {
    "subject": "a small glass vase on a wooden table",
    "camera": "static", "aspect_ratio": "1:1",
}
prompt: str = build_prompt(scene)

The Python edition has no browser component, telemetry, background jobs, or application initialization step. Importing the module loads only bundled JSON data; it never contacts the external reference pages. The API uses snake_case field names consistently, including aspect_ratio, duration_seconds, and default_duration_seconds.

Examples included in the package

• examples/product_demo.py composes a product prompt and exports a three-shot plan.
• examples/storyboard.py combines nature templates into a short two-shot storyboard.

The source project also contains unit tests, executable documentation examples, and cross-runtime fixture checks. Tests are development files and are intentionally excluded from the published runtime archive. The published examples use only the package's own exports and do not require provider credentials.

Troubleshooting

A separate discussion-profile reference is Reference 07: discussion profile.

An unknown-field error appears. Check the spelling of the field against the prompt interface. Provider-specific parameters such as model names, seeds, resolution, or credits are not part of this local planner. Configure those separately in the tool you use.

The action looks too complicated. Break it into smaller shots. A scene with several interactions can be grammatically clear while still being an impractical request for a short generated clip.

The output contains unwanted writing. Remove instructions that imply exact signage or labels, keep the scene visually simple, and add the required typography afterward. Negative text is not a guarantee that unwanted writing will disappear.

The character changes between shots. Repeat concrete identifying details, use the reference controls offered by your generator, and inspect each result. The package cannot enforce cross-generation identity.

The result does not match the planned duration or frame. Storyboard durations and aspect-ratio descriptions are planning metadata and prompt text. They do not control generation settings. Select compatible settings in your provider or editor.

A formatted storyboard is rejected after manual editing. Check the shot indices, start times, end times, durations, and total. They must form a contiguous sequence. Recreate the plan with create_storyboard when unsure.

Frequently asked questions

Does this package generate videos?

No. It returns prompt text and storyboard data. It does not render, download, or host media.

Is an API key required?

No. All exported functions work locally. Any credentials required by a separate generation service belong to that service and are not handled by this package.

Are the templates guaranteed to work with every model?

No. They provide readable creative instructions, not verified model-specific syntax. Review and adapt them to your actual tool and settings.

Can I replace the built-in subject and action?

Yes. Use build_from_template with overrides, or retrieve a template copy and edit its fields before calling build_prompt.

Can I add my own templates?

Yes. Store your own scene dictionaries in your application and pass them to the composer. This release does not provide a global template-registration API or write changes back to its built-in JSON files.

Does it translate prompts?

No. Text is preserved apart from whitespace normalization. You can supply your own language, but the package does not perform translation or infer a model's preferred language.

Does it guarantee a seamless loop or accurate simulation?

No. Loop and demonstration templates express an intention. Inspect the result, validate relevant details, and use editing where needed.

Can it validate generated media?

No. Input validation checks local data shape and storyboard timing. It does not analyze images, assess movement, verify scientific claims, or compare a generated clip with a reference.

Does it send prompts anywhere?

No. There are no network calls, telemetry events, remote template updates, or background uploads in the runtime code.

Privacy, limitations, and license

A separate personal-profile reference is Reference 10: profile page.

Your application decides where to store or send the generated text. The toolkit itself does not collect it. When integrating the composer into a larger system, review that system's logging, analytics, provider requests, and retention rules separately; local behavior in this package does not establish privacy properties for another service.

The toolkit is intended for creative planning, not as a substitute for an editor, a factual review, a technical simulation, or the controls of a video-generation interface. It cannot enforce model behavior, establish service availability, or guarantee a specific artistic result.

The package is distributed under the MIT License. See LICENSE for the full terms. The initial release includes the offline composer, template library, preset dictionaries, storyboard planner, examples, and declarations described above. Future interfaces are not promised by this README.

Python integration patterns

Keep prompt construction separate from provider submission. A command-line script can read a scene dictionary from a JSON file, call build_prompt, and write the resulting text to standard output. A notebook can browse list_templates() and copy the returned fields into a cell for editing. A web application can validate its form input server-side and display a preview without transmitting that text to any generation service. All three workflows use the same local functions.

For repeatable experiments, save the input dictionary alongside the generated prompt and note which template identifier you started with. If you change a subject, camera movement, and visual treatment simultaneously, it becomes difficult to identify which change helped. Keep a small experiment log with one intentional change per iteration. This package does not write that log automatically, because storage location and retention policy belong to the application using it.

The returned template, preset, and reference values are copies. You can edit a template dictionary, append an application-specific reference to a returned list, or change the wording of a preset in your own configuration without modifying the built-in data. Copying is not a versioning mechanism: persist your modified inputs explicitly if they must survive a process restart. The bundled library remains the same until you deliberately install another release.

Storyboards are JSON-compatible planning records, not a video file format. A downstream editor can use their start times and durations as a draft timeline, but this package does not create subtitles, render frames, synthesize audio, or enforce cuts. Check the final result with the media tools you use. A JSON round trip preserves the plan's values; format_storyboard still checks timing consistency after loading a record that may have been manually edited.

Handle invalid input with a focused message. TypeError indicates a wrong data type or an unexpected key; ValueError indicates a disallowed value, missing subject, unsupported ratio, unknown template, or invalid timing. Neither exception proves that the creative description is accurate. Validation does not moderate a scene, resolve contradictory instructions, certify a teaching example, or guarantee a provider will follow the prompt.

The reference helper is optional. Calling list_references() only returns ten strings from a bundled JSON file. It does not request a URL, test indexing, inspect a profile, submit a bookmark, or validate any claim made on an external page. Keep any network fetching in a separate application component with its own error handling. The supplied links can change or become unavailable independently of this release.