@melite/models-trellis2-native 0.0.0-stage → 0.1.5-pre-alpha

package/LICENSE

@@ -0,0 +1,557 @@
+                     Server Side Public License
+                     VERSION 1, OCTOBER 16, 2018
+
+                    Copyright © 2018 MongoDB, Inc.
+
+  Everyone is permitted to copy and distribute verbatim copies of this
+  license document, but changing it is not allowed.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+  
+  “This License” refers to Server Side Public License.
+
+  “Copyright” also means copyright-like laws that apply to other kinds of
+  works, such as semiconductor masks.
+
+  “The Program” refers to any copyrightable work licensed under this
+  License.  Each licensee is addressed as “you”. “Licensees” and
+  “recipients” may be individuals or organizations.
+
+  To “modify” a work means to copy from or adapt all or part of the work in
+  a fashion requiring copyright permission, other than the making of an
+  exact copy. The resulting work is called a “modified version” of the
+  earlier work or a work “based on” the earlier work.
+
+  A “covered work” means either the unmodified Program or a work based on
+  the Program.
+
+  To “propagate” a work means to do anything with it that, without
+  permission, would make you directly or secondarily liable for
+  infringement under applicable copyright law, except executing it on a
+  computer or modifying a private copy. Propagation includes copying,
+  distribution (with or without modification), making available to the
+  public, and in some countries other activities as well.
+
+  To “convey” a work means any kind of propagation that enables other
+  parties to make or receive copies. Mere interaction with a user through a
+  computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays “Appropriate Legal Notices” to the
+  extent that it includes a convenient and prominently visible feature that
+  (1) displays an appropriate copyright notice, and (2) tells the user that
+  there is no warranty for the work (except to the extent that warranties
+  are provided), that licensees may convey the work under this License, and
+  how to view a copy of this License. If the interface presents a list of
+  user commands or options, such as a menu, a prominent item in the list
+  meets this criterion.
+
+  1. Source Code.
+
+  The “source code” for a work means the preferred form of the work for
+  making modifications to it. “Object code” means any non-source form of a
+  work.
+
+  A “Standard Interface” means an interface that either is an official
+  standard defined by a recognized standards body, or, in the case of
+  interfaces specified for a particular programming language, one that is
+  widely used among developers working in that language.  The “System
+  Libraries” of an executable work include anything, other than the work as
+  a whole, that (a) is included in the normal form of packaging a Major
+  Component, but which is not part of that Major Component, and (b) serves
+  only to enable use of the work with that Major Component, or to implement
+  a Standard Interface for which an implementation is available to the
+  public in source code form. A “Major Component”, in this context, means a
+  major essential component (kernel, window system, and so on) of the
+  specific operating system (if any) on which the executable work runs, or
+  a compiler used to produce the work, or an object code interpreter used
+  to run it.
+
+  The “Corresponding Source” for a work in object code form means all the
+  source code needed to generate, install, and (for an executable work) run
+  the object code and to modify the work, including scripts to control
+  those activities. However, it does not include the work's System
+  Libraries, or general-purpose tools or generally available free programs
+  which are used unmodified in performing those activities but which are
+  not part of the work. For example, Corresponding Source includes
+  interface definition files associated with source files for the work, and
+  the source code for shared libraries and dynamically linked subprograms
+  that the work is specifically designed to require, such as by intimate
+  data communication or control flow between those subprograms and other
+  parts of the work.
+
+  The Corresponding Source need not include anything that users can
+  regenerate automatically from other parts of the Corresponding Source.
+
+  The Corresponding Source for a work in source code form is that same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+  copyright on the Program, and are irrevocable provided the stated
+  conditions are met. This License explicitly affirms your unlimited
+  permission to run the unmodified Program, subject to section 13. The
+  output from running a covered work is covered by this License only if the
+  output, given its content, constitutes a covered work. This License
+  acknowledges your rights of fair use or other equivalent, as provided by
+  copyright law.  Subject to section 13, you may make, run and propagate
+  covered works that you do not convey, without conditions so long as your
+  license otherwise remains in force. You may convey covered works to
+  others for the sole purpose of having them make modifications exclusively
+  for you, or provide you with facilities for running those works, provided
+  that you comply with the terms of this License in conveying all
+  material for which you do not control copyright. Those thus making or
+  running the covered works for you must do so exclusively on your
+  behalf, under your direction and control, on terms that prohibit them
+  from making any copies of your copyrighted material outside their
+  relationship with you.
+
+  Conveying under any other circumstances is permitted solely under the
+  conditions stated below. Sublicensing is not allowed; section 10 makes it
+  unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+  measure under any applicable law fulfilling obligations under article 11
+  of the WIPO copyright treaty adopted on 20 December 1996, or similar laws
+  prohibiting or restricting circumvention of such measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+  circumvention of technological measures to the extent such circumvention is
+  effected by exercising rights under this License with respect to the
+  covered work, and you disclaim any intention to limit operation or
+  modification of the work as a means of enforcing, against the work's users,
+  your or third parties' legal rights to forbid circumvention of
+  technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+  receive it, in any medium, provided that you conspicuously and
+  appropriately publish on each copy an appropriate copyright notice; keep
+  intact all notices stating that this License and any non-permissive terms
+  added in accord with section 7 apply to the code; keep intact all notices
+  of the absence of any warranty; and give all recipients a copy of this
+  License along with the Program.  You may charge any price or no price for
+  each copy that you convey, and you may offer support or warranty
+  protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+  produce it from the Program, in the form of source code under the terms
+  of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified it,
+    and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is released
+    under this License and any conditions added under section 7. This
+    requirement modifies the requirement in section 4 to “keep intact all
+    notices”.
+
+    c) You must license the entire work, as a whole, under this License to
+    anyone who comes into possession of a copy. This License will therefore
+    apply, along with any applicable section 7 additional terms, to the
+    whole of the work, and all its parts, regardless of how they are
+    packaged. This License gives no permission to license the work in any
+    other way, but it does not invalidate such permission if you have
+    separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your work
+    need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+  works, which are not by their nature extensions of the covered work, and
+  which are not combined with it such as to form a larger program, in or on
+  a volume of a storage or distribution medium, is called an “aggregate” if
+  the compilation and its resulting copyright are not used to limit the
+  access or legal rights of the compilation's users beyond what the
+  individual works permit. Inclusion of a covered work in an aggregate does
+  not cause this License to apply to the other parts of the aggregate.
+  
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms of
+  sections 4 and 5, provided that you also convey the machine-readable
+  Corresponding Source under the terms of this License, in one of these
+  ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium customarily
+    used for software interchange.
+   
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a written
+    offer, valid for at least three years and valid for as long as you
+    offer spare parts or customer support for that product model, to give
+    anyone who possesses the object code either (1) a copy of the
+    Corresponding Source for all the software in the product that is
+    covered by this License, on a durable physical medium customarily used
+    for software interchange, for a price no more than your reasonable cost
+    of physically performing this conveying of source, or (2) access to
+    copy the Corresponding Source from a network server at no charge.
+   
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source. This alternative is
+    allowed only occasionally and noncommercially, and only if you received
+    the object code with such an offer, in accord with subsection 6b.
+   
+    d) Convey the object code by offering access from a designated place
+    (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge. You need not require recipients to copy the
+    Corresponding Source along with the object code. If the place to copy
+    the object code is a network server, the Corresponding Source may be on
+    a different server (operated by you or a third party) that supports
+    equivalent copying facilities, provided you maintain clear directions
+    next to the object code saying where to find the Corresponding Source.
+    Regardless of what server hosts the Corresponding Source, you remain
+    obligated to ensure that it is available for as long as needed to
+    satisfy these requirements.
+   
+    e) Convey the object code using peer-to-peer transmission, provided you
+    inform other peers where the object code and Corresponding Source of
+    the work are being offered to the general public at no charge under
+    subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+  from the Corresponding Source as a System Library, need not be included
+  in conveying the object code work.
+
+  A “User Product” is either (1) a “consumer product”, which means any
+  tangible personal property which is normally used for personal, family,
+  or household purposes, or (2) anything designed or sold for incorporation
+  into a dwelling. In determining whether a product is a consumer product,
+  doubtful cases shall be resolved in favor of coverage. For a particular
+  product received by a particular user, “normally used” refers to a
+  typical or common use of that class of product, regardless of the status
+  of the particular user or of the way in which the particular user
+  actually uses, or expects or is expected to use, the product. A product
+  is a consumer product regardless of whether the product has substantial
+  commercial, industrial or non-consumer uses, unless such uses represent
+  the only significant mode of use of the product.
+
+  “Installation Information” for a User Product means any methods,
+  procedures, authorization keys, or other information required to install
+  and execute modified versions of a covered work in that User Product from
+  a modified version of its Corresponding Source. The information must
+  suffice to ensure that the continued functioning of the modified object
+  code is in no case prevented or interfered with solely because
+  modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+  specifically for use in, a User Product, and the conveying occurs as part
+  of a transaction in which the right of possession and use of the User
+  Product is transferred to the recipient in perpetuity or for a fixed term
+  (regardless of how the transaction is characterized), the Corresponding
+  Source conveyed under this section must be accompanied by the
+  Installation Information. But this requirement does not apply if neither
+  you nor any third party retains the ability to install modified object
+  code on the User Product (for example, the work has been installed in
+  ROM).
+
+  The requirement to provide Installation Information does not include a
+  requirement to continue to provide support service, warranty, or updates
+  for a work that has been modified or installed by the recipient, or for
+  the User Product in which it has been modified or installed. Access
+  to a network may be denied when the modification itself materially
+  and adversely affects the operation of the network or violates the
+  rules and protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided, in
+  accord with this section must be in a format that is publicly documented
+  (and with an implementation available to the public in source code form),
+  and must require no special password or key for unpacking, reading or
+  copying.
+
+  7. Additional Terms.
+
+  “Additional permissions” are terms that supplement the terms of this
+  License by making exceptions from one or more of its conditions.
+  Additional permissions that are applicable to the entire Program shall be
+  treated as though they were included in this License, to the extent that
+  they are valid under applicable law. If additional permissions apply only
+  to part of the Program, that part may be used separately under those
+  permissions, but the entire Program remains governed by this License
+  without regard to the additional permissions.  When you convey a copy of
+  a covered work, you may at your option remove any additional permissions
+  from that copy, or from any part of it. (Additional permissions may be
+  written to require their own removal in certain cases when you modify the
+  work.) You may place additional permissions on material, added by you to
+  a covered work, for which you have or can give appropriate copyright
+  permission.
+
+  Notwithstanding any other provision of this License, for material you add
+  to a covered work, you may (if authorized by the copyright holders of
+  that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some trade
+    names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that material
+    by anyone who conveys the material (or modified versions of it) with
+    contractual assumptions of liability to the recipient, for any
+    liability that these contractual assumptions directly impose on those
+    licensors and authors.
+
+  All other non-permissive additional terms are considered “further
+  restrictions” within the meaning of section 10. If the Program as you
+  received it, or any part of it, contains a notice stating that it is
+  governed by this License along with a term that is a further restriction,
+  you may remove that term. If a license document contains a further
+  restriction but permits relicensing or conveying under this License, you
+  may add to a covered work material governed by the terms of that license
+  document, provided that the further restriction does not survive such
+  relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you must
+  place, in the relevant source files, a statement of the additional terms
+  that apply to those files, or a notice indicating where to find the
+  applicable terms.  Additional terms, permissive or non-permissive, may be
+  stated in the form of a separately written license, or stated as
+  exceptions; the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+  provided under this License. Any attempt otherwise to propagate or modify
+  it is void, and will automatically terminate your rights under this
+  License (including any patent licenses granted under the third paragraph
+  of section 11).
+
+  However, if you cease all violation of this License, then your license
+  from a particular copyright holder is reinstated (a) provisionally,
+  unless and until the copyright holder explicitly and finally terminates
+  your license, and (b) permanently, if the copyright holder fails to
+  notify you of the violation by some reasonable means prior to 60 days
+  after the cessation.
+
+  Moreover, your license from a particular copyright holder is reinstated
+  permanently if the copyright holder notifies you of the violation by some
+  reasonable means, this is the first time you have received notice of
+  violation of this License (for any work) from that copyright holder, and
+  you cure the violation prior to 30 days after your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+  licenses of parties who have received copies or rights from you under
+  this License. If your rights have been terminated and not permanently
+  reinstated, you do not qualify to receive new licenses for the same
+  material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or run a
+  copy of the Program. Ancillary propagation of a covered work occurring
+  solely as a consequence of using peer-to-peer transmission to receive a
+  copy likewise does not require acceptance. However, nothing other than
+  this License grants you permission to propagate or modify any covered
+  work. These actions infringe copyright if you do not accept this License.
+  Therefore, by modifying or propagating a covered work, you indicate your
+  acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically receives
+  a license from the original licensors, to run, modify and propagate that
+  work, subject to this License. You are not responsible for enforcing
+  compliance by third parties with this License.
+
+  An “entity transaction” is a transaction transferring control of an
+  organization, or substantially all assets of one, or subdividing an
+  organization, or merging organizations. If propagation of a covered work
+  results from an entity transaction, each party to that transaction who
+  receives a copy of the work also receives whatever licenses to the work
+  the party's predecessor in interest had or could give under the previous
+  paragraph, plus a right to possession of the Corresponding Source of the
+  work from the predecessor in interest, if the predecessor has it or can
+  get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the rights
+  granted or affirmed under this License. For example, you may not impose a
+  license fee, royalty, or other charge for exercise of rights granted
+  under this License, and you may not initiate litigation (including a
+  cross-claim or counterclaim in a lawsuit) alleging that any patent claim
+  is infringed by making, using, selling, offering for sale, or importing
+  the Program or any portion of it.
+
+  11. Patents.
+
+  A “contributor” is a copyright holder who authorizes use under this
+  License of the Program or a work on which the Program is based. The work
+  thus licensed is called the contributor's “contributor version”.
+
+  A contributor's “essential patent claims” are all patent claims owned or
+  controlled by the contributor, whether already acquired or hereafter
+  acquired, that would be infringed by some manner, permitted by this
+  License, of making, using, or selling its contributor version, but do not
+  include claims that would be infringed only as a consequence of further
+  modification of the contributor version. For purposes of this definition,
+  “control” includes the right to grant patent sublicenses in a manner
+  consistent with the requirements of this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+  patent license under the contributor's essential patent claims, to make,
+  use, sell, offer for sale, import and otherwise run, modify and propagate
+  the contents of its contributor version.
+
+  In the following three paragraphs, a “patent license” is any express
+  agreement or commitment, however denominated, not to enforce a patent
+  (such as an express permission to practice a patent or covenant not to
+  sue for patent infringement). To “grant” such a patent license to a party
+  means to make such an agreement or commitment not to enforce a patent
+  against the party.
+
+  If you convey a covered work, knowingly relying on a patent license, and
+  the Corresponding Source of the work is not available for anyone to copy,
+  free of charge and under the terms of this License, through a publicly
+  available network server or other readily accessible means, then you must
+  either (1) cause the Corresponding Source to be so available, or (2)
+  arrange to deprive yourself of the benefit of the patent license for this
+  particular work, or (3) arrange, in a manner consistent with the
+  requirements of this License, to extend the patent license to downstream
+  recipients. “Knowingly relying” means you have actual knowledge that, but
+  for the patent license, your conveying the covered work in a country, or
+  your recipient's use of the covered work in a country, would infringe
+  one or more identifiable patents in that country that you have reason
+  to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+  arrangement, you convey, or propagate by procuring conveyance of, a
+  covered work, and grant a patent license to some of the parties receiving
+  the covered work authorizing them to use, propagate, modify or convey a
+  specific copy of the covered work, then the patent license you grant is
+  automatically extended to all recipients of the covered work and works
+  based on it.
+
+  A patent license is “discriminatory” if it does not include within the
+  scope of its coverage, prohibits the exercise of, or is conditioned on
+  the non-exercise of one or more of the rights that are specifically
+  granted under this License. You may not convey a covered work if you are
+  a party to an arrangement with a third party that is in the business of
+  distributing software, under which you make payment to the third party
+  based on the extent of your activity of conveying the work, and under
+  which the third party grants, to any of the parties who would receive the
+  covered work from you, a discriminatory patent license (a) in connection
+  with copies of the covered work conveyed by you (or copies made from
+  those copies), or (b) primarily for and in connection with specific
+  products or compilations that contain the covered work, unless you
+  entered into that arrangement, or that patent license was granted, prior
+  to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting any
+  implied license or other defenses to infringement that may otherwise be
+  available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+  otherwise) that contradict the conditions of this License, they do not
+  excuse you from the conditions of this License. If you cannot use,
+  propagate or convey a covered work so as to satisfy simultaneously your
+  obligations under this License and any other pertinent obligations, then
+  as a consequence you may not use, propagate or convey it at all. For
+  example, if you agree to terms that obligate you to collect a royalty for
+  further conveying from those to whom you convey the Program, the only way
+  you could satisfy both those terms and this License would be to refrain
+  entirely from conveying the Program.
+
+  13. Offering the Program as a Service.
+
+  If you make the functionality of the Program or a modified version
+  available to third parties as a service, you must make the Service Source
+  Code available via network download to everyone at no charge, under the
+  terms of this License. Making the functionality of the Program or
+  modified version available to third parties as a service includes,
+  without limitation, enabling third parties to interact with the
+  functionality of the Program or modified version remotely through a
+  computer network, offering a service the value of which entirely or
+  primarily derives from the value of the Program or modified version, or
+  offering a service that accomplishes for users the primary purpose of the
+  Program or modified version.
+
+  “Service Source Code” means the Corresponding Source for the Program or
+  the modified version, and the Corresponding Source for all programs that
+  you use to make the Program or modified version available as a service,
+  including, without limitation, management software, user interfaces,
+  application program interfaces, automation software, monitoring software,
+  backup software, storage software and hosting software, all such that a
+  user could run an instance of the service using the Service Source Code
+  you make available.  
+
+  14. Revised Versions of this License.
+
+  MongoDB, Inc. may publish revised and/or new versions of the Server Side
+  Public License from time to time. Such new versions will be similar in
+  spirit to the present version, but may differ in detail to address new
+  problems or concerns.
+
+  Each version is given a distinguishing version number. If the Program
+  specifies that a certain numbered version of the Server Side Public
+  License “or any later version” applies to it, you have the option of
+  following the terms and conditions either of that numbered version or of
+  any later version published by MongoDB, Inc. If the Program does not
+  specify a version number of the Server Side Public License, you may
+  choose any version ever published by MongoDB, Inc.
+
+  If the Program specifies that a proxy can decide which future versions of
+  the Server Side Public License can be used, that proxy's public statement
+  of acceptance of a version permanently authorizes you to choose that
+  version for the Program.
+
+  Later license versions may give you additional or different permissions.
+  However, no additional obligations are imposed on any author or copyright holder
+  as a result of your choosing to follow a later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+  APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS 
+  AND/OR OTHER PARTIES PROVIDE THE PROGRAM “AS IS” WITHOUT WARRANTY
+  OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+  IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+  ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+  
+  16. Limitation of Liability.
+  
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+  WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+  THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING
+  ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF
+  THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO
+  LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU
+  OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+  PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+  POSSIBILITY OF SUCH DAMAGES.
+  
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided above
+  cannot be given local legal effect according to their terms, reviewing
+  courts shall apply local law that most closely approximates an absolute
+  waiver of all civil liability in connection with the Program, unless a
+  warranty or assumption of liability accompanies a copy of the Program in
+  return for a fee.
+  
+                        END OF TERMS AND CONDITIONS

package/README.md

@@ -1,3 +1,36 @@
-# Temporary Holding Version
+---
+description: TRELLIS.2 Native family — background-removed image to textured GLB through voxel structure, shape, and texture stages, with the mesh action on the ComfyUI engine.
+kind: package-library
+---
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# @melite/models-trellis2-native
+
+`@melite/models-trellis2-native` is the model family package for TRELLIS.2 on native ComfyUI (`form_img_to_mesh`, genre 3d): background-removed conditioning flows to a voxel structure, a shape latent, and a texture atlas, saved as a `.glb`. The DECL declares the `mesh` action, a three-resolution variant rail, and the five-file lift-chain provisioning. The estate boot mounts it as a Cordis plugin through `ctx.models.registerFamily` inside `ctx.effect`; the img-to-mesh card binds the action. The lane is this package's own `actions.ts`, pinned to committed goldens.
+
+## Declaration
+
+Variants: `1024` (default; BF16 at ~12 GB VRAM peak or INT8 ConvRot at ~8 GB), `1536` (hero quality; 16/10 GB), and a hidden fast `512`. Family defaults fix the sampler table (euler/normal structure and shape, euler/simple then euler/normal texture), `steps` 12 / `shape_steps` 20, `cfg` 7.5, remesh at 768 faces decimated to 700k, atlas 4096, AO 1024, normal 2048, `sd3_shift` 5, and `seed` 42. The `mesh` action requires `input_image` — the 3D lift is image-conditioned and takes no text prompt — and its facts door refuses any of the five load keys missing: `unet`, `vae`, `texture_vae`, `clip_vision`, `background_removal`. Provisions pin the weights, including `birefnet.safetensors` from Comfy-Org's BiRefNet repo for background removal. The build runs structure, shape, upsample, remesh, texture, and the atlas/AO/normal bakes, then saves through `MeshToFile3D` + `Save3DAdvanced`.
+
+## Model Experience
+
+### Request context and condition
+
+#### What the model sees
+
+- **input_image** — required; the source image the lift conditions on.
+- **resolution / bg_removal** — the closed variant table and the birefnet on/off/auto pick.
+- **sampler rows and seed** — the per-stage sampler/scheduler/steps/cfg table and the sentinel-minted seed.
+
+#### Token effect
+
+Zero-direct token effect — the fields ride the composed ComfyUI graph; no harness context is spent.
+
+#### KV Cache effect
+
+Independent — each mesh run is its own engine request; no shared prefix.
+
+## Known Limitations and Deferred Work
+
+- **No text conditioning** — the lane accepts no prompt; shape intent must come from the image alone.
+- **VRAM peaks are cell-declared** — the 8–16 GB figures are the DECL's measured rows, not runtime guarantees on every GPU.
+- **Image quality ceiling** — background removal and texture fidelity are not verified against the running engine.

package/lib/actions.d.ts

@@ -0,0 +1,25 @@
+import type { ComfyActionSpec } from "@melite/comfyui-card-kit";
+import { type LaneInputsFacts } from "@melite/comfyui-card-kit/facts";
+/** The closed facts shape the mesh segment reads (the lift chain's
+ * five load keys, resolved from the row's lane_inputs). */
+export type MeshFacts = {
+    readonly unet: string;
+    readonly vae: string;
+    readonly texture_vae: string;
+    readonly clip_vision: string;
+};
+/** The gated params doc the mesh segment reads (the card's schema
+ * walk validated types and bounds — a same-process typed boundary;
+ * the seed arrives minted through the declared seed-sentinel rule,
+ * so the ported chain's own mint is a pass-through). */
+export type MeshParams = Record<string, unknown>;
+/** The mesh facts door: the resolved lane_inputs parsed into the
+ * closed shape — a missing load key refuses field-named here,
+ * never composes a loader on an empty directory.
+ *  @param raw the resolved lane_inputs (family ⊕ variant)
+ *  @returns the typed facts the segment factory reads */
+export declare function parseMeshFacts(raw: LaneInputsFacts): MeshFacts;
+/** The mesh action: trellis_t1 — DINOv3 conditioning (the image IS
+ * the prompt; the negative is the conditioning's own output 1). */
+export declare const mesh: ComfyActionSpec<MeshParams, MeshFacts>;
+//# sourceMappingURL=actions.d.ts.map

package/lib/actions.js

@@ -0,0 +1,258 @@
+import { requireText } from "@melite/comfyui-card-kit/facts";
+import { MESH_RESOLUTIONS, MESH_ATLAS_SIZES, MESH_AO_SIZES, MESH_NORMAL_SIZES, admitMeshLiftShared, isSpell } from "@melite/comfyui-card-kit";
+import { SAMPLER_OPTIONS, SCHEDULER_OPTIONS } from "@melite/comfyui-card-kit/vocab";
+/** The mesh facts door: the resolved lane_inputs parsed into the
+ * closed shape — a missing load key refuses field-named here,
+ * never composes a loader on an empty directory.
+ *  @param raw the resolved lane_inputs (family ⊕ variant)
+ *  @returns the typed facts the segment factory reads */
+export function parseMeshFacts(raw) {
+    return {
+        unet: requireText(raw, 'unet', 'trellis2-native mesh'),
+        vae: requireText(raw, 'vae', 'trellis2-native mesh'),
+        texture_vae: requireText(raw, 'texture_vae', 'trellis2-native mesh'),
+        clip_vision: requireText(raw, 'clip_vision', 'trellis2-native mesh'),
+    };
+}
+/** The wired-tensor law (the lanes-image precedent, ported 1:1):
+ *  a '$name' value names an upstream stage's wired output — the
+ *  spell IS the tensor and rides node inputs verbatim. ROW-4
+ *  refuses producer links in Load* file slots, so a spelled image
+ *  NEVER builds a loader; file paths keep the disk handoff. */
+/** The lift arms' admission slice for THIS family: the SHARED kit
+ *  seat (the dry-sweep's J4 re-hoist — two families carried this
+ *  verbatim; the required image and closed sets refuse in the
+ *  slice, never in the schema). This family adds no private arm
+ *  (the pixal-only camera_fov row is pixal's, not ours). */
+const admitMeshLift = admitMeshLiftShared;
+/** The dual guided unet + the two VAEs — the lift chain's shared
+ * head. Creation order lands the reference renderers' numbering: the SHAPE
+ * pair first (CFGOverride.0/RescaleCFG.0), then the STRUCT pair
+ * (.1). */
+function loadLiftHeads(g, li, p) {
+    const unet = g.node('UNETLoader', { unet_name: li.unet, weight_dtype: 'default' }).out();
+    // shape arm (0.769 / 0.5) — numbered FIRST (served order)
+    const overrideShape = g.node('CFGOverride', {
+        model: unet, cfg: 1.0,
+        start_percent: p.override_shape, end_percent: 1.0,
+    }).out();
+    const rescaleShape = g.node('RescaleCFG', {
+        model: overrideShape, multiplier: p.rescale_shape,
+    }).out();
+    // struct arm (0.667 / 0.7) — numbered SECOND (served order)
+    const overrideStruct = g.node('CFGOverride', {
+        model: unet, cfg: 1.0,
+        start_percent: p.override_struct, end_percent: 1.0,
+    }).out();
+    const rescaleStruct = g.node('RescaleCFG', {
+        model: overrideStruct, multiplier: p.rescale_struct,
+    }).out();
+    const shifted = g.node('ModelSamplingSD3', {
+        model: rescaleStruct, shift: p.sd3_shift,
+    }).out();
+    const shapeVae = g.node('VAELoader', { vae_name: li.vae }).out();
+    const texVae = g.node('VAELoader', { vae_name: li.texture_vae }).out();
+    return { unet, rescaleShape, shifted, shapeVae, texVae };
+}
+/** The shared structure→shape→upsample→texture→bake→glb chain
+ * (_shared_lift_chain verbatim — the model delta lives
+ * ENTIRELY in the conditioning pair passed in). */
+function sharedLiftChain(g, p, heads, pos, neg, prefix) {
+    const seed = p.seed;
+    const { unet, rescaleShape, shifted, shapeVae, texVae } = heads;
+    // structure stage (the lift): card steps + cfg knobs
+    const empty = g.node('EmptyTrellis2LatentStructure', { batch_size: 1 }).out();
+    const struct = g.node('KSampler', {
+        seed, steps: p.steps, cfg: p.cfg,
+        sampler_name: p.struct_sampler,
+        scheduler: p.struct_scheduler, denoise: 1.0,
+        model: shifted, positive: pos, negative: neg, latent_image: empty,
+    });
+    const voxel = g.node('VaeDecodeStructureTrellis2', {
+        samples: struct.out(), vae: shapeVae, resolution: '32',
+    }).out();
+    // shape stage: 20 steps / cfg 7.5 on the 0.5 arm (official)
+    const shapeStage = g.node('Trellis2ShapeStage', { positive: pos, negative: neg, voxel });
+    const shapeLatent = g.node('KSampler', {
+        seed, steps: p.shape_steps,
+        cfg: p.shape_cfg,
+        sampler_name: p.shape_sampler,
+        scheduler: p.shape_scheduler, denoise: 1.0,
+        model: rescaleShape,
+        positive: shapeStage.out(0), negative: shapeStage.out(1),
+        latent_image: shapeStage.out(2),
+    });
+    // upsample + first texture pass: UNCONDITIONAL, target floored at 1024
+    const up = g.node('Trellis2UpsampleStage', {
+        positive: shapeStage.out(0), negative: shapeStage.out(1),
+        shape_latent: shapeLatent.out(), vae: shapeVae,
+        target_resolution: Math.max(Number(p.resolution), 1024),
+    });
+    const upLatent = g.node('KSampler', {
+        seed, steps: p.tex1_steps,
+        cfg: p.tex1_cfg,
+        sampler_name: p.tex1_sampler,
+        scheduler: p.tex1_scheduler, denoise: 1.0,
+        model: rescaleShape,
+        positive: up.out(0), negative: up.out(1), latent_image: up.out(2),
+    });
+    // mesh lineage: decode → info → UDF remesh → exact-count decimate
+    const decodeShape = g.node('VaeDecodeShapeTrellis', { samples: upLatent.out(), vae: shapeVae });
+    const mesh = decodeShape.out(0);
+    const subdivides = decodeShape.out(1);
+    const info = g.node('GetMeshInfo', { mesh }).out(0);
+    const remeshed = g.node('RemeshMesh', {
+        mesh: info, resolution: p.remesh_resolution,
+        sign_mode: 'udf',
+        
+        // card's schema defaults (false) ARE the pinned core defaults
+        'sign_mode.qef': p.remesh_qef === true,
+        'sign_mode.drop_inverted_components': p.remesh_drop_inverted === true,
+        'sign_mode.drop_enclosed_components': p.remesh_drop_enclosed === true,
+        smooth_iters: 20,
+        drop_small_components: 0.01, precluster_max_verts: 20000000,
+        // pin autofills leaves in place (core defaults)
+        band: 1.0, fix_poles: p.remesh_fix_poles === true, project_back: 0.0,
+    }).out();
+    // texture stage, two passes: 12/7.5/simple feeds the stage; 12/1.0
+    // on the RAW unet samples it (official template KSampler#12)
+    const texStage = g.node('Trellis2TextureStage', {
+        positive: up.out(0), negative: up.out(1), shape_latent: upLatent.out(),
+    });
+    const texLatent = g.node('KSampler', {
+        seed, steps: p.tex2_steps,
+        cfg: p.tex2_cfg,
+        sampler_name: p.tex2_sampler,
+        scheduler: p.tex2_scheduler, denoise: 1.0,
+        model: unet,
+        positive: texStage.out(0), negative: texStage.out(1),
+        latent_image: texStage.out(2),
+    });
+    const voxelColors = g.node('VaeDecodeTextureTrellis', {
+        samples: texLatent.out(), vae: texVae, shape_subdivides: subdivides,
+    }).out();
+    // bake tail: decimate → smooth → unwrap → bake color/AO/normal →
+    // apply → smooth → glb (the textured mesh is the saved hero)
+    const decimated = g.node('DecimateMesh', {
+        mesh: remeshed, target_face_count: p.decimate_faces,
+        placement_mode: 'midpoint',
+    }).out();
+    const smooth1 = g.node('MeshSmoothNormals', {
+        mesh: decimated, crease_angle: p.smooth_angle,
+    }).out();
+    const unwrapped = g.node('UnwrapMesh', {
+        mesh: smooth1, segmenter: 'pec', resolution: Number(p.atlas_size),
+        padding: 1, weld_distance: 0.0002,
+    }).out();
+    const baked = g.node('BakeTextureFromVoxel', {
+        mesh: unwrapped, voxel_colors: voxelColors,
+        texture_size: Number(p.atlas_size), reference_mesh: mesh,
+    });
+    const occlusion = g.node('BakeAmbientOcclusion', {
+        low_poly: unwrapped, high_poly: remeshed,
+        resolution: Number(p.ao_size),
+        samples: 64, max_distance: 0.71, strength: 1.0, bias: 0.01,
+    }).out();
+    const normalMap = g.node('BakeNormalMapFromMesh', {
+        low_poly: unwrapped, high_poly: remeshed,
+        resolution: Number(p.normal_size),
+        cage_distance: 0.05, ignore_backfaces: true,
+    }).out();
+    const textured = g.node('ApplyTextureToMesh', {
+        mesh: unwrapped,
+        base_color: baked.out(0), metallic: baked.out(1),
+        roughness: baked.out(2),
+        occlusion, normal_map: normalMap,
+    }).out();
+    const smooth2 = g.node('MeshSmoothNormals', {
+        mesh: textured, crease_angle: p.smooth_angle,
+    }).out();
+    const glb = g.node('MeshToFile3D', { mesh: smooth2 }).out();
+    return g.node('Save3DAdvanced', {
+        model_3d: glb, filename_prefix: prefix,
+        viewport_state: '', width: 1024, height: 1024,
+    }).out();
+}
+/** The mesh action: trellis_t1 — DINOv3 conditioning (the image IS
+ * the prompt; the negative is the conditioning's own output 1). */
+export const mesh = {
+    id: "mesh",
+    inputs: [],
+    outputs: [{ name: "glb", kind: "GLB" }],
+    // THE DECLARED SURFACE (the write plane, phase 2): the
+    // img-to-mesh card schema's own types and bounds — the family
+    // door judges defaults and variant presets against this row.
+    // The closed sets (resolutions, bg modes, bake sizes) are the
+    // card-kit's ONE mesh vocabularies; the sampler/scheduler rows
+    // resolve from the ONE engine vocabulary.
+    params: [
+        { name: "input_image", type: "string" },
+        { name: "seed", type: "number", rule: "seed-sentinel" },
+        { name: "resolution", type: "enum", options: MESH_RESOLUTIONS },
+        { name: "steps", type: "number", bounds: [4, 60] },
+        { name: "cfg", type: "number", bounds: [1, 15] },
+        { name: "shape_steps", type: "number", bounds: [4, 60] },
+        { name: "shape_cfg", type: "number", bounds: [1, 15] },
+        { name: "shape_sampler", type: "enum", options: SAMPLER_OPTIONS },
+        { name: "shape_scheduler", type: "enum", options: SCHEDULER_OPTIONS },
+        { name: "tex1_steps", type: "number", bounds: [4, 60] },
+        { name: "tex1_cfg", type: "number", bounds: [1, 15] },
+        { name: "tex1_sampler", type: "enum", options: SAMPLER_OPTIONS },
+        { name: "tex1_scheduler", type: "enum", options: SCHEDULER_OPTIONS },
+        { name: "tex2_steps", type: "number", bounds: [4, 60] },
+        { name: "tex2_cfg", type: "number", bounds: [1, 15] },
+        { name: "tex2_sampler", type: "enum", options: SAMPLER_OPTIONS },
+        { name: "tex2_scheduler", type: "enum", options: SCHEDULER_OPTIONS },
+        { name: "struct_sampler", type: "enum", options: SAMPLER_OPTIONS },
+        { name: "struct_scheduler", type: "enum", options: SCHEDULER_OPTIONS },
+        { name: "remesh_resolution", type: "number", bounds: [128, 2048] },
+        { name: "remesh_qef", type: "boolean" },
+        { name: "remesh_drop_inverted", type: "boolean" },
+        { name: "remesh_drop_enclosed", type: "boolean" },
+        { name: "remesh_fix_poles", type: "boolean" },
+        { name: "decimate_faces", type: "number", bounds: [10000, 2000000] },
+        { name: "smooth_angle", type: "number", bounds: [0, 180] },
+        { name: "atlas_size", type: "enum", options: MESH_ATLAS_SIZES },
+        { name: "ao_size", type: "enum", options: MESH_AO_SIZES },
+        { name: "normal_size", type: "enum", options: MESH_NORMAL_SIZES },
+        { name: "sd3_shift", type: "number", bounds: [1, 10] },
+        { name: "rescale_struct", type: "number", bounds: [0.1, 1] },
+        { name: "rescale_shape", type: "number", bounds: [0.1, 1] },
+        { name: "override_struct", type: "number", bounds: [0, 1] },
+        { name: "override_shape", type: "number", bounds: [0, 1] },
+    ],
+    facts: parseMeshFacts,
+    build({ p, facts, g }) {
+        admitMeshLift(p);
+        const li = facts;
+        // THE SPELLED ANCHOR (the gap-audit law: img-to-mesh seats
+        // input_image, so a producer CAN wire in — the spell rides the
+        // conditioning tensor verbatim, never a loader).
+        const img = isSpell(p.input_image)
+            ? p.input_image
+            : g.node('LoadImage', { image: p.input_image }).out();
+        const heads = loadLiftHeads(g, li, p);
+        // THE TEMPLATE HAS NO MASK BRIDGE: the crop eats the photo
+        // (LoadImage) verbatim — a MaskToImage-sourced crop feeds the
+        // silhouette, and the silhouette starves every appearance
+        
+        // IMAGE for its masks leg.
+        const cropped = g.node('ImageCropToMask', {
+            images: img, masks: img,
+            pad_factor: 1.1, width: 1024, height: 1024,
+            // pin autofills leaves in place (core defaults)
+            background: '#000000', grow_mask: 0,
+        }).out();
+        const clip = g.node('CLIPVisionLoader', { clip_name: li.clip_vision }).out();
+        const cond = g.node('Trellis2Conditioning', { clip_vision_model: clip, image: cropped });
+        const pos = cond.out(0);
+        // the negative IS the conditioning's second output — never a
+        // fabricated zero (the zero drops the shared proj pack the
+        // template routes as every pass's negative)
+        const neg = cond.out(1);
+        // Family constant, never a knob (compose stamps the prefix
+        // internally; stable).
+        return sharedLiftChain(g, p, heads, pos, neg, 'trellis2_native');
+    },
+};
+//# sourceMappingURL=actions.js.map

package/lib/index.d.ts

@@ -0,0 +1,7 @@
+import type { Plugin } from "@deepseek-ai/cordis";
+import type { ModelDecl } from '@melite/comfyui-card-kit/model-contract';
+export declare const DECL: ModelDecl;
+export declare const family: Plugin;
+export { mesh } from "./actions.js";
+export { family as default };
+//# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -0,0 +1,214 @@
+import { mesh } from "./actions.js";
+export const DECL = {
+    "id": "trellis2-native",
+    "form": "form_img_to_mesh",
+    "label": "TRELLIS.2 Native",
+    "description": "Image to textured 3D mesh (native ComfyUI TRELLIS.2): background-removed conditioning → voxel structure → shape latent → texture atlas, saved as a .glb.",
+    "engine": "comfyui",
+    "defaults": {
+        
+        // standard / quality, defaulting to standard): the floors ARE the
+        // standard tier — 1024 + the template's 768/700k tail (the card
+        // schema carries no remesh default, so this row is the raw-compose
+        // floor; the surviving 1024 lane stamps none, and the quality
+        // recipe's 1536/2048/2M picks override these as patch-only rows).
+        "resolution": "1024",
+        "steps": 12,
+        "cfg": 7.5,
+        "shape_steps": 20,
+        "shape_cfg": 7.5,
+        "tex1_steps": 12,
+        "tex1_cfg": 7.5,
+        "tex2_steps": 12,
+        "tex2_cfg": 1,
+        "remesh_resolution": 768,
+        "decimate_faces": 700000,
+        "smooth_angle": 180,
+        "atlas_size": "4096",
+        "ao_size": "1024",
+        "normal_size": "2048",
+        "struct_sampler": "euler",
+        "struct_scheduler": "normal",
+        "shape_sampler": "euler",
+        "shape_scheduler": "normal",
+        "tex1_sampler": "euler",
+        "tex1_scheduler": "simple",
+        "tex2_sampler": "euler",
+        "tex2_scheduler": "normal",
+        "sd3_shift": 5,
+        "rescale_struct": 0.7,
+        "rescale_shape": 0.5,
+        "override_struct": 0.667,
+        "override_shape": 0.769,
+        "seed": -1
+    },
+    "studio": {
+        "tenant": "3d/img-to-mesh",
+        "owns_params": false,
+        "writes": [
+            "input_image",
+            "rigged_glb",
+            "target_glb"
+        ],
+        "kind": "assembly",
+        "size": "normal",
+        "layout": "studio"
+    },
+    "genre": "3d",
+    "variants": [
+        {
+            "id": "1024",
+            "label": "1024",
+            "hint": "Standard resolution — the fast tier",
+            "group": "Variant",
+            "route": "trellis2-native",
+            // no resolver_defaults — the family defaults row owns
+            // resolution (one value, one owner); this row IS the lane
+            "order": 0,
+            "cells": [
+                {
+                    "quant": "bf16",
+                    "label": "BF16",
+                    "hide_from_dropdown": true,
+                    "route": "trellis2-native-bf16",
+                    "vram_peak_gb": 12,
+                },
+                {
+                    "quant": "int8",
+                    "label": "INT8 ConvRot",
+                    "route": "trellis2-native-int8",
+                    "vram_peak_gb": 8,
+                }
+            ]
+        },
+        
+        // standard, quality on the img to mesh node, defaulting to
+        // standard"). Resolution rides ONE seat — the family defaults
+        // row's 1024 — so fast and standard leave it unstated and only
+        // quality restates the 1536 pick (the card's closed enum owns
+        // the vocabulary: 1024 | 1536; the hidden 512 lane was
+        // off-envelope and died with its variant row). The remesh tail
+        // rides the family defaults row (the floors ARE the standard —
+        // the h3 precedent: a recipe stamps only what DIFFERS from the
+        // floor). STANDARD is the stamp-less first row: the birth stamp
+        // takes the FIRST Recipe row, so every fresh card lands here
+        // named Standard with the calibration riding as floors.
+        {
+            "id": "standard",
+            "label": "Standard",
+            "hint": "The default — the official template's calibration as the floor: 1024 + remesh 768 + 700k faces; fits a 24GB card.",
+            "group": "Recipe",
+            "cells": [],
+        },
+        {
+            "id": "fast",
+            "label": "Fast",
+            "hint": "Preview tier — remesh 128 + 10k faces at the same 1024 floor; the lightest mesh that still unwraps.",
+            "group": "Recipe",
+            "wire_defaults": { "remesh_resolution": 128, "decimate_faces": 10000 },
+            "cells": [],
+        },
+        {
+            "id": "quality",
+            "label": "Quality",
+            "hint": "Hero assets — resolution 1536 + remesh 2048 + 2M faces; RemeshMesh wants ~3.6 GiB over a ~19 GiB resident chain (32GB+ VRAM only).",
+            "group": "Recipe",
+            "wire_defaults": { "resolution": "1536", "remesh_resolution": 2048, "decimate_faces": 2000000 },
+            "cells": [],
+        },
+    ],
+    "variant_groups": [
+        {
+            "id": "Variant",
+            "label": "Variant",
+        },
+        {
+            "id": "Quant",
+            "label": "Quant",
+        },
+        {
+            "id": "Recipe",
+            "label": "Recipe",
+            "tooltip": "One-click mesh tiers — patch-only rows: Fast (preview tail), Standard (the calibrated default), Quality (1536 hero pass).",
+            "default": "standard"
+        }
+    ],
+    "provisions": [
+        {
+            "name": "trellis_2_int8_convrot.safetensors",
+            "url": "https://huggingface.co/Comfy-Org/TRELLIS.2/resolve/main/diffusion_models/trellis_2_int8_convrot.safetensors",
+            "folder": "diffusion_models",
+            "sha256": "d01952ad137213f6a868f86b6b877026276f84af5eec23069217475a0bad3a31",
+            "size_bytes": 5253048192
+        },
+        {
+            "name": "trellis_2_shape_vae_bf16.safetensors",
+            "url": "https://huggingface.co/Comfy-Org/TRELLIS.2/resolve/main/vae/trellis_2_shape_vae_bf16.safetensors",
+            "folder": "vae",
+            "sha256": "de0cb4949a76c59ee5c091a995a69bcc8c51d5aeda939f0c641a50d2a72341f4",
+            "size_bytes": 1095844024
+        },
+        {
+            "name": "trellis_2_texture_vae_bf16.safetensors",
+            "url": "https://huggingface.co/Comfy-Org/TRELLIS.2/resolve/main/vae/trellis_2_texture_vae_bf16.safetensors",
+            "folder": "vae",
+            "sha256": "714e5ebf094a610e12a8e3b5175c18a62f37f6ea4218acb6073644456b73ab0e",
+            "size_bytes": 948461364
+        },
+        {
+            "name": "dino_v3_vit_l.safetensors",
+            "url": "https://huggingface.co/Comfy-Org/TRELLIS.2/resolve/main/clip_vision/dino_v3_vit_l.safetensors",
+            "folder": "clip_vision",
+            "sha256": "5cb785e458de7c460579082418af81f5c62380c181599344bdc60898c63468ee",
+            "size_bytes": 1212559776
+        }
+    ],
+    "lane_inputs": {
+        "clip_vision": "dino_v3_vit_l.safetensors",
+        "texture_vae": "trellis_2_texture_vae_bf16.safetensors",
+        "unet": "trellis_2_int8_convrot.safetensors",
+        "vae": "trellis_2_shape_vae_bf16.safetensors"
+    },
+    // THE DECLARED HOME (the lane-presence cure): the store folder this
+    // pack-specific lane file lives in — the run gate probes it at press
+    // instead of dying untyped at the engine.
+    "lane_homes": { "texture_vae": "vae" },
+    // THE LANE SURFACE (the z-image precedent): exactly the knobs the
+    // img-to-mesh card serves — the mesh lift, its shape/texture
+    // passes, the remesh/decimate tail, and the per-pass sampler pairs.
+    "params": [
+        "input_image", "rigged_glb", "target_glb",
+        "seed", "resolution", "steps", "cfg",
+        "camera_fov",
+        "shape_steps", "shape_cfg", "tex1_steps", "tex1_cfg",
+        "tex2_steps", "tex2_cfg",
+        "remesh_resolution", "remesh_qef", "remesh_drop_inverted",
+        "remesh_drop_enclosed", "remesh_fix_poles",
+        "decimate_faces", "smooth_angle",
+        "atlas_size", "ao_size", "normal_size",
+        "struct_sampler", "struct_scheduler",
+        "shape_sampler", "shape_scheduler",
+        "tex1_sampler", "tex1_scheduler",
+        "tex2_sampler", "tex2_scheduler",
+        "sd3_shift",
+        "rescale_struct", "rescale_shape",
+        "override_struct", "override_shape",
+    ],
+    // the mesh action the img-to-mesh card binds (the trellis_t1
+    // lane tree).
+    "actions": [mesh],
+};
+export const family = {
+    name: "family-trellis2-native",
+    inject: ["models"],
+    apply(ctx) {
+        ctx.effect(() => ctx.models.registerFamily(DECL));
+    },
+};
+export { mesh } from "./actions.js";
+// The Loader-row face: DSH loads plugin rows by bare specifier and
+// unwraps `exports.default ?? exports` (vendor/cordis_plugins/loader
+// unwrapExports) — the default export IS the row-loadable plugin. The
+// named `family` stays the library face (engine loadFamilies).
+export { family as default };
+//# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,36 @@
 {
   "name": "@melite/models-trellis2-native",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.5-pre-alpha",
+  "license": "SSPL-1.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@melite/comfyui-card-kit": "0.1.5-pre-alpha"
+  },
+  "devDependencies": {
+    "@types/node": "^22.20.0",
+    "typescript": "^5.9.3",
+    "@deepseek-ai/cordis": "^4.0.4"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/**/*.js",
+    "lib/**/*.d.ts"
+  ],
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.4"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}